def tz_to_utc(dt, tz, ignoretz=True):
"""Converts a datetime object from the specified timezone to a UTC datetime.
:param tz: the timezone the datetime is currently in. tz can be passed
as a string or as a timezone object. (i.e. 'US/Central' or
pytz.timezone('US/Central'), etc)
:param ignoretz: will ignore the timezone portion of the datetime object and
tzinfo will be None.
:return: the datetime object by in UTC time.
Examples:
>>> tz_to_utc(datetime.datetime(2011, 11, 25, 9), 'US/Central')
2011-11-25 15:00:00
>>> tz_to_utc(datetime.datetime(2011, 11, 25, 9), pytz.timezone('US/Central'))
2011-11-25 15:00:00
>>> tz_to_utc(datetime.datetime(2011, 11, 25, 9), 'US/Central', False)
2011-11-25 15:00:00+00:00
"""
if isinstance(tz, string_types):
tz = pytz.timezone(tz)
dt = tz.localize(dt)
dt = datetime.datetime.astimezone(dt, pytz.timezone('UTC'))
if ignoretz:
return dt.replace(tzinfo=None)
return dt
def utc_to_tz(dt, tz, ignoretz=True):
""" Converts UTC datetime object to the specific timezone.
:param dt: the UTC datetime object to convert.
:param tz: the timezone to convert the UTC datetime object info. tz can be
passed as a string or as a timezone object. (i.e. 'US/Central' or
pytz.timezone('US/Central'), etc)
:param ignoretz: will ignore the timezone portion of the datetime object and
tzinfo will be None.
:return: the datetime object by in UTC time.
Examples:
>>> utc_to_tz(datetime.datetime(2011, 11, 25, 9), pytz.timezone('US/Central'))
2011-11-25 03:00:00
>>> utc_to_tz(datetime.datetime(2011, 11, 25, 9), 'US/Central', False)
2011-11-25 03:00:00-06:00
"""
if isinstance(tz, string_types):
tz = pytz.timezone(tz)
dt = pytz.utc.localize(dt)
dt = dt.astimezone(tz)
if ignoretz:
return dt.replace(tzinfo=None)
return dt
def handle(self, *args, **options):
handle = urllib.urlopen(URL)
data = handle.read()
content = json.loads(data)
for item in content:
updated = None
if item['last_change']:
updated = make_aware(
parser.parse(item['last_change']),
pytz.timezone('Europe/Prague'),
)
params = {
'name': item['name'],
'translated': item['translated'],
'percent': item['translated_percent'],
'updated': updated,
}
translation, created = Translation.objects.get_or_create(
url=item['url_translate'],
defaults=params
)
if not created:
modified = False
for key in params:
if getattr(translation, key) != params[key]:
setattr(translation, key, params[key])
modified = True
if modified:
translation.save()
def now_by_tz(tz='US/Central', ignoretz=True):
"""Gets the current datetime object by timezone.
:param tz: is the timezone to get the date for. tz can be passed as a
string or as a timezone object. (i.e. 'US/Central' or
pytz.timezone('US/Central'), etc)
:param ignoretz: will ignore the timezone portion of the datetime object and
tzinfo will be None.
:return: the current datetime object by tz
Examples:
>>> now_by_tz('US/Pacific')
2011-09-28 10:06:01.130025
>>> now_by_tz('US/Pacific', False)
2011-09-28 10:06:01.130025-07:00
>>> now_by_tz(pytz.timezone('US/Central'))
2011-09-28 12:06:01.130025
>>> now_by_tz(pytz.timezone('US/Central'), False)
2011-09-28 12:06:01.130025-05:00
"""
if isinstance(tz, string_types):
tz = pytz.timezone(tz)
if ignoretz:
return datetime.datetime.now(tz).replace(tzinfo=None)
return datetime.datetime.now(tz)
def refresh_services(self):
response = requests.get(
'%s?access_token=%s' % (
PROFILES_URL,
self.token
),
timeout = TIMEOUT
)
if response.status_code == 200:
self.services.all().delete()
services = {}
for profile in response.json():
remote_id = profile['formatted_service']
if remote_id in services:
service = services[remote_id]
else:
service = self.services.create(
remote_id = profile[u'service_id'],
name = remote_id,
username = profile['service_username']
)
services[service.remote_id] = service
epoch = datetime(1970, 1, 1, 0, 0, 0,
tzinfo = pytz.timezone(
profile['timezone']
)
)
service.profiles.create(
avatar = profile.get('avatar_https',
profile.get('avatar')
),
created_at = epoch + timedelta(
seconds = profile['created_at']
),
default = profile['default'],
selected = profile['default'],
formatted_username = profile['formatted_username'],
remote_id = profile['id'],
schedules = json.dumps(
profile['schedules']
)
)
else:
log.error(response.json(), request)
def process_request(self, request):
tz = request.session.get('user_timezone')
if tz:
try:
timezone.activate(pytz.timezone(tz))
except:
timezone.deactivate()
else:
timezone.deactivate()
# Add datetime info the the request. So date/time can be put in context
# of the user.
user_datetime = localtime(datetime.utcnow().replace(tzinfo=utc))
request.user_date = user_datetime.date()
request.user_datetime = user_datetime
def text(self, strip_html=False):
"""Creates the text representation of the notification."""
value = ""
try:
time_zone = pytz.timezone("Europe/Madrid")
target_date = timezone.localtime(self.target.departure, time_zone)
target_date = localize(target_date)
if self.verb == JOIN:
# actor is a user and target is a journey
value = _(
"%(user)s ha <strong>solicitado</strong> unirse al viaje <strong>%(journey)s</strong> del %(date)s"
) % {
"user": six.text_type(self.actor),
"journey": six.text_type(self.target).lower(),
"date": target_date,
}
elif self.verb == LEAVE:
value = _(
"%(user)s ha <strong>abandonado</strong> el viaje <strong>%(journey)s</strong> del %(date)s"
) % {
"user": six.text_type(self.actor),
"journey": six.text_type(self.target).lower(),
"date": target_date,
}
elif self.verb == THROW_OUT:
value = _(
"%(user)s te ha <strong>expulsado</strong> del viaje <strong>%(journey)s</strong> del %(date)s"
) % {
"user": six.text_type(self.actor),
"journey": six.text_type(self.target).lower(),
"date": target_date,
}
elif self.verb == CONFIRM:
value = _(
"%(user)s te ha <strong>confirmado</strong> para el viaje <strong>%(journey)s</strong> del %(date)s"
) % {
"user": six.text_type(self.actor),
"journey": six.text_type(self.target).lower(),
"date": target_date,
}
elif self.verb == REJECT:
value = _(
"%(user)s te ha <strong>rechazado</strong> para el viaje <strong>%(journey)s</strong> del %(date)s"
) % {
"user": six.text_type(self.actor),
"journey": six.text_type(self.target).lower(),
"date": target_date,
}
elif self.verb == CANCEL:
value = _(
"El viaje <strong>%(journey)s</strong> del %(date)s ha sido <strong>cancelado</strong>"
) % {
"journey": six.text_type(self.actor).lower(),
"date": target_date,
}
elif self.verb == MESSAGE:
value = _(
"%(user)s ha mandado un <strong>nuevo mensaje</strong> en <strong>%(journey)s</strong> del %(date)s"
) % {
"user": six.text_type(self.actor),
"journey": six.text_type(self.target).lower(),
"date": target_date,
}
except AttributeError:
pass
if strip_html:
value = strip_tags(value)
return mark_safe(value)
def pay_notify(request):
try:
paymethod = Pay.getPayMethod(PayAccount.Nowpay)
account = paymethod.getAccount(True)
pay = Nowpay()
logger.info("Received nowpay asynchronized pure notify '%s'" %(request.body))
parameters = {k: v[0] for k, v in parse_qs(request.body).iteritems()}
parameters['mhtOrderName'] = unicode(parameters['mhtOrderName'], "utf-8")
logger.info("Received nowpay asynchronized notify at %s with parameters '%s'." %(datetime.now(),
'&'.join(['%s=%s' % (key, v) for key,v in parameters.iteritems()])))
if parameters['appId'] == account.pid:
# and parameters['signature'] ==\
# pay.doSign(parameters, ('mhtSignType', 'mhtSignature'), account.key):
tradenum = parameters['mhtOrderNo']
try:
transaction = Transaction.objects.get(id=getIdFromTradeNum(tradenum))
if transaction.tradeStatus == 'TRADE_FINISHED' or transaction.tradeStatus == 'TRADE_CLOSED':
# already completed transaction
return HttpResponse("success=Y")
elif parameters['tradeStatus'] == 'A001':
if 'nowPayAccNo' in parameters:
transaction.paytradeNum = parameters['tradeStatus']
transaction.tradeStatus = 'TRADE_SUCCESS'
transaction.paidDate = datetime.now().replace(tzinfo=utc).astimezone(pytz.timezone(TIME_ZONE))
transaction.state = 2
transaction.save()
transactionSuccessNotification(transaction)
return HttpResponse("success=Y")
logger.warn('Notify the transcation with error code %s.' %(parameters['tradeStatus']))
except Transaction.DoesNotExist:
#TODO handle error case
pass
else:
logger.warn("nowpay notify is illegal.")
except Exception, e:
logger.error("exception occurred when processing nowpay notification.")
logger.exception(e)
def generate_yml_file():
groups = Group.objects.all().order_by('id')
attr_names = ['Тип часов', 'Цвет']
gender_values = Value.objects.filter(attribute__name__in=attr_names)
values_l_2 = Value.objects.filter(value_enum__in=[
'Кварцевые', 'Механические', 'Спортивный', 'цифровой (электронный)'
])
root_nodes = Node.objects.filter(_depth=1,
attribute_values__in=gender_values)
nodes_l_2 = Node.objects.filter(parent__in=root_nodes,
_depth=2,
attribute_values__in=values_l_2)
country_values = Value.objects.filter(attribute__name='Страна')
parent_nodes = nodes_l_2.union(root_nodes)
parents = [parent for parent in parent_nodes]
nodes_l_3 = Node.objects.filter(parent__in=parents).filter(
attribute_values__in=country_values)
nodes = root_nodes.union(nodes_l_2)
nodes = nodes.union(nodes_l_3)
nodes = [node.id for node in nodes]
root = Node.objects.get(_depth=0)
nodes.append(root.id)
qs = Node.objects.filter(id__in=nodes).exclude(
name__contains='Swiss Military')
nodes = list(qs)
nodes.sort(key=sorting_function)
for category in Node.objects.all():
cat_av = category.attribute_values.all()
cat_av_set = {v.id for v in cat_av}
for node in nodes:
node_av = node.attribute_values.all()
node_av_set = {v.id for v in node_av}
difference = node_av_set.difference(cat_av_set)
if len(difference) == 0 and node._depth != 0:
category.add_rr_node(node)
category = Node.objects.get(_depth=0)
category.add_rr_node(category)
products = Product.objects.available()
date = now().astimezone(pytz.timezone(
settings.TIME_ZONE)).strftime('%Y-%m-%d %H:%M')
context = {
'base_url':
'https://presidentwatches.ru',
'date':
date,
'categories':
nodes,
'qs':
qs,
'products':
products,
'get_nodes_by_product':
lambda qs, product: get_nodes_by_product(qs, product),
'club_prices':
lambda instance: club_prices(groups=groups, instance=instance)
}
xml_raw = render_to_string(template_name="api/retail-rocket.xml",
context=context)
with open(FILEPATH, "w") as fp:
fp.write(xml_raw)
def ready(self):
"""
set datetime in utc for job schedule
"""
date_now = datetime.datetime.utcnow()
year = date_now.year
month = date_now.month
day = date_now.day
timezone_local = pytz.timezone(settings.TIME_ZONE)
date_schedule_sendmail = datetime.datetime.strptime(
settings.SEND_MAIL_TIME, '%H:%M:%S')
hour_sendmail = date_schedule_sendmail.hour
minutes_sendmail = date_schedule_sendmail.minute
seconds_sendmail = date_schedule_sendmail.second
date_schedule_sendmail = datetime.datetime(year, month, day,
hour_sendmail,
minutes_sendmail,
seconds_sendmail)
date_schedule_sendmail = timezone_local.localize(
date_schedule_sendmail)
date_schedule_sendmail = date_schedule_sendmail.astimezone(pytz.utc)
date_schedule_clear = datetime.datetime.strptime(
settings.CLEAR_OLD_TOPICS_TIME, '%H:%M:%S')
hour_clear = date_schedule_clear.hour
minutes_clear = date_schedule_clear.minute
seconds_clear = date_schedule_clear.second
date_schedule_clear = datetime.datetime(year, month, day, hour_clear,
minutes_clear, seconds_clear)
date_schedule_clear = timezone_local.localize(date_schedule_clear)
date_schedule_clear = date_schedule_clear.astimezone(pytz.utc)
while date_schedule_sendmail <= datetime.datetime.utcnow().astimezone(
pytz.utc):
date_schedule_sendmail = date_schedule_sendmail + datetime.timedelta(
seconds=settings.SEND_MAIL_INTERVAL)
while date_schedule_clear <= datetime.datetime.utcnow().astimezone(
pytz.utc):
date_schedule_clear = date_schedule_clear + datetime.timedelta(
seconds=settings.CLEAR_OLD_TOPICS_INTERVAL)
from . import jobs
try:
scheduler = django_rq.get_scheduler('default')
for job in scheduler.get_jobs():
if job.func_name == 'forumTopics.jobs.sendmail':
job.delete()
if job.func_name == 'forumTopics.jobs.deleteOldTopics':
job.delete()
scheduler.schedule(scheduled_time=date_schedule_sendmail,
func=jobs.sendmail,
interval=settings.SEND_MAIL_INTERVAL,
result_ttl=settings.SEND_MAIL_INTERVAL + 300)
scheduler.schedule(scheduled_time=date_schedule_clear,
func=jobs.deleteOldTopics,
interval=settings.CLEAR_OLD_TOPICS_INTERVAL,
result_ttl=settings.CLEAR_OLD_TOPICS_INTERVAL +
300)
count_send_mail = 0
count_deleteOldTopics = 0
for job in scheduler.get_jobs():
if job.func_name == 'forumTopics.jobs.sendmail':
count_send_mail += 1
if count_send_mail > 1:
job.delete()
if job.func_name == 'forumTopics.jobs.deleteOldTopics':
count_deleteOldTopics += 1
if count_deleteOldTopics > 1:
job.delete()
except ConnectionError:
pass
def today_alberta_tz():
return datetime.now(pytz.timezone('America/Edmonton')).date()
def assistant_offer_booking_by_uuid(request, assistant_uuid):
if request.user.is_authenticated():
if request.user.cellphone is None or request.user.cellphone == '':
return HttpResponse(
simplejson.dumps({
'code': 16,
'msg': 'missing contact information'
}))
try:
offer_booking = simplejson.loads(request.body)
offerday = datetime.datetime.utcfromtimestamp(
float(offer_booking['offerDay'])).replace(
tzinfo=utc).astimezone(pytz.timezone(settings.TIME_ZONE))
if (offerday -
datetime.datetime.now().replace(tzinfo=utc)).days <= 2:
offerhour = int(offer_booking['offerHour'])
offerday = offerday.replace(hour=offerhour, minute=0)
offerduring = int(offer_booking['offerDuring'])
assistant = Assistant.objects.filter(ASSISTANT_FILTER).get(
uuid=uuid.UUID(assistant_uuid))
assistantsOffers = AssistantOffer.objects.filter(
ASSISTANT_OFFER_FILTER).filter(assistant=assistant).filter(
day=getattr(
AssistantOffer.day, AssistantOffer.day._flags[
offerday.weekday()]))
offertimerange = [
offerday, offerday + datetime.timedelta(hours=offerduring)
]
for offer in assistantsOffers:
if offer.starttime.hour <= offerhour and offer.endtime.hour > offerhour and offer.endtime.hour >= (
offerhour + offerduring):
appoints = AssistantAppointment.objects.filter(
ASSISTANTAPPOINTMENT_FILTER).filter(
assistant=assistant).filter(
(Q(starttime__gte=offertimerange[0])
& Q(starttime__lt=offertimerange[1]))
| (Q(endtime__gt=offertimerange[0])
& Q(endtime__lte=offertimerange[1])))
if appoints.exists():
available_payment = True
for appoint in appoints:
if (appoint.transaction.state == 2 or appoint.transaction.state == 5) or \
(appoint.transaction.state == 1 and not appoint.transaction.paymentExpired):
if appoint.user == request.user:
return HttpResponse(
simplejson.dumps({
'code':
2,
'msg':
'order has been created',
'state':
appoint.state
}))
else:
available_payment = False
else:
appoint.state = 8
appoint.transaction.state = 3
appoint.transaction.save()
appoint.save()
if not available_payment:
return HttpResponse(
simplejson.dumps({
'code': 1,
'msg': 'unavailable'
}))
# retrieve/create a goods
name = u"预约%s %s点 至 %s点" % (
offer.assistant.nickname,
offertimerange[0].strftime("%Y-%m-%d %H"),
offertimerange[1].strftime("%H"))
hashvalue = hashlib.md5(
u"%s %s-%s" %
(offer.assistant.uuid, offertimerange[0],
offertimerange[1])).hexdigest().upper()
goods, created = Goods.objects.get_or_create(
sku=hashvalue,
defaults={
'name': name,
'description': name,
'price': offer.price * offerduring,
# goods, created = Goods.objects.get_or_create(sku=hashvalue, defaults={'name': name, 'description': name, 'price':0.01,
'type': 2,
'sku': hashvalue
})
transaction, url = createTransaction(request, goods)
transaction.validUntilDate = datetime.datetime.now(
) + timedelta(minutes=Pay.PAYMENT_TIMEOUT)
transaction.save()
AssistantAppointment.objects.create(
assistant=assistant,
user=request.user,
poolroom=offer.poolroom,
goods=goods,
transaction=transaction,
starttime=offertimerange[0],
endtime=offertimerange[1],
duration=offerduring,
price=goods.price,
createdDate=datetime.datetime.now(),
state=1)
return HttpResponse(
simplejson.dumps({
'code': 0,
'msg': 'order is created.',
'payurl': url
}))
return HttpResponse(
simplejson.dumps({
'code': -3,
'msg': 'illegal data'
}))
return HttpResponse(
simplejson.dumps({
'code': -2,
'msg': 'illegal day'
}))
except Assistant.DoesNotExist:
return HttpResponse(
simplejson.dumps({
'code': -1,
'msg': 'illegal data'
}))
except ValueError:
return HttpResponse(
simplejson.dumps({
'code': -1,
'msg': 'illegal data'
}))
raise PermissionDenied("login firstly.")
def create_verification_code(request):
""" Sends verification code to the specified user and saves all required data for its further verification.
:request_field integer user_id: BotMother user platform_id.
:request_field string phone_number: Phone number to be verified.
:response_field boolean success
:special_error string error: "Try later"
:special_error_field integer seconds_left: How many seconds left until user can use this hook again.
"""
user_id = int(request.POST['user_id'])
phone_number = str(request.POST['phone_number'])
try:
phone_number = phonenumbers.parse(phone_number, "RU")
if phone_number.italian_leading_zero or len(
str(phone_number.national_number)) != 10:
return JsonResponse({
"success": False,
"error": "Phone number wrong"
})
except phonenumbers.phonenumberutil.NumberParseException:
return JsonResponse({"success": False, "error": "Phone number wrong"})
if BotUser.objects.filter(bot_user_id=user_id).first() is None:
return JsonResponse({
"success": False,
"error": "User with this id doesn't exist"
})
user = BotUser.objects.get(bot_user_id=user_id)
if user.phone_number_verified:
# User has already verified his phone
return JsonResponse({
"success": False,
"error": "User with this id has verified his phone"
})
elif BotUser.objects.filter(phone_number=phone_number).first() is not None:
confirmed_user = BotUser.objects.get(phone_number=phone_number)
if confirmed_user.phone_number_verified:
# Someone already verified this phone
return JsonResponse({
"success": False,
"error": "This phone is already used"
})
elif user.phones_changed_at_auth > settings.MAX_PHONE_CHANGES:
dt_now = now().astimezone(pytz.timezone(settings.TIME_ZONE))
time_delta = dt_now - user.last_phone_change_try
if time_delta < settings.MIN_TD_WHEN_MAX_PHONE_CHANGES_EXCEED:
# Too many verification requests, user should wait
seconds_left = (settings.MIN_TD_WHEN_MAX_PHONE_CHANGES_EXCEED -
time_delta).seconds
return JsonResponse({
"success": False,
"error": "Try later",
"seconds_left": seconds_left
})
verification_code = generate_verification_code()
status_code, json_data = send_verification_code(verification_code,
phone_number)
if status_code != 200 or json_data['code'] != 1:
# Couldn't send verification code
logger.error(
"Code not sent to {}{}. Request body is {}. SMS API status code {}, response {}"
.format(phone_number.country_code, phone_number.national_number,
request.body, status_code, json_data))
return JsonResponse({"success": False, "error": "Couldn't send code"})
else:
user.phone_number = phone_number
user.phone_verification_code = verification_code
user.phones_changed_at_auth += 1
user.last_phone_change_try = now().astimezone(
pytz.timezone(settings.TIME_ZONE))
user.save()
return JsonResponse({"success": True})
def get_date_obj(date_list):
moscow_tz = pytz.timezone('Europe/Moscow')
return moscow_tz.localize(datetime(*date_list))
def orders(request):
date = datetime.now()
apply_filters(request, 'order_filters', {'date', 'status', 'org', 'user', 'paid'})
if request.method == 'POST' and request.user.has_perm('ofd_app.manage_order_status'):
id = to_int(request.POST.get('order_id', 0), 0)
status = request.POST.get('status', '').strip()
admin_comment = request.POST.get('admin_comment', '').strip()
codes = request.POST.get('order_codes', '').strip()
if id > 0 and len(status) > 0:
try:
order = Order.objects.get(id=id)
op_result = order.assign_status(status, admin_comment, codes)
if op_result:
logging.info(f'id:{request.user.id}, username:{request.user.username} - изменил статус заказа № МО-{order.id} на {status}.')
send_mail(
TEMPLATE_EMAIL_ORDER_STATUS_USER_SUBJECT,
TEMPLATE_EMAIL_ORDER_STATUS_USER_BODY.format(
number = id,
date = order.adddate.astimezone(pytz.timezone(TIME_ZONE)).strftime("%Y.%m.%d %H:%M:%S"),
total = order.amount * order.cost,
product = order.product.product_name,
amount = order.amount,
status = MESSAGES[0] if status == 'R' else MESSAGES[1],
comment_template = 'Комментарий администратора: ' if admin_comment else '',
comment = admin_comment if admin_comment else ''
),
EMAIL_HOST_USER,
[order.user.email],
fail_silently=False
)
logging.info(f'Отправлен email на {order.user.email}.')
except Order.DoesNotExist:
logging.warning(f'id:{request.user.id}, username:{request.user.username} - пытался изменить статус несуществующего заказа!')
date_from = datetime.strptime(request.session['order_filters']['date_from'], date_filter_format())
date_to = datetime.strptime(request.session['order_filters']['date_to'], date_filter_format())
org = request.session['order_filters']['org']
status = request.session['order_filters']['status']
user = request.session['order_filters']['user']
paid = request.session['order_filters']['paid']
orders = Order.get_orders(request.user, date_from, date_to, status, org, user, paid)
order_data = []
for order in orders:
product = {
'product_name': order.product.product_name,
'amount' : order.amount, 'cost': order.cost,
'full_cost' : order.amount * order.cost
}
order_data.append({
'id' : order.id,
'adddate' : order.adddate.astimezone(pytz.timezone(TIME_ZONE)).strftime("%d.%m.%y %H:%M"),
'comment' : order.comment,
'product' : product,
'status' : order.status.code,
'user' : order.user,
'user_role' : order.user_role,
'admin_comment': order.admin_comment,
'codes' : order.codes,
'is_paid' : order.is_paid,
'allow_receipt': (DATE_AFTER_WHICH_INVOICES_WILL_BE_ISSUED - order.adddate).days < 0
})
filters = {}
if request.user.is_superuser or request.user.is_admin():
filters['org'] = User.get_organizations()
elif request.user.is_manager():
filters['users'] = [{'id': request.user.id, 'first_name': request.user.first_name, 'last_name': request.user.last_name}]
for item in request.user.get_childs():
child = {'id': item['id'], 'first_name': item['first_name'], 'last_name': item['last_name']}
filters['users'].append(child)
filters['status'] = OrderStatus.get_all_statuses()
return render(request, 'ofd_app/orders.html', {'orders': construct_pagination(request, order_data), 'filters': filters, 'user_role': request.user.get_role(), 'path': ORDERS})
def saveChallenge(request, issuer, poolroom, challenge = None, source = 1, location = None, username = None, group = 1):
starttime = datetime.datetime.fromtimestamp(float(request.POST['starttime'])/1000, pytz.timezone(TIME_ZONE))
expiredtime = datetime.datetime.fromtimestamp(float(request.POST['expiredtime'])/1000, pytz.timezone(TIME_ZONE))
saveChallenge2(issuer, poolroom, starttime, expiredtime, request.POST['nickname'], request.POST['level'], request.POST['tabletype'],
request.POST['rule'], request.POST['contact'], 'waiting' if challenge is None else request.POST['status'], challenge, source, location, username, group)
def saveMatch(request, poolroomid, match = None, organizer = 1, matchtype = 1):
attributelist = []
if request.POST['groupon'] == 'true':
attributelist.append('groupon')
if request.POST['coupon'] == 'true':
attributelist.append('coupon')
starttime = datetime.datetime.fromtimestamp(float(request.POST['matchtime'])/1000, pytz.timezone(TIME_ZONE))
data = {
'title': request.POST['matchtitle'],
'bonus': request.POST['cashbonus'],
'rechargeablecard': request.POST['cardbonous'],
'otherprize': request.POST['otherbonous'],
'bonusdetail': request.POST['bonusdetail'],
'rule': request.POST['matchrule'],
'description': request.POST['description'],
'starttime': starttime,
'enrollfee': request.POST['enrollfee'],
'enrollfocal': request.POST['enrollfocal'],
'flags': attributelist,
'organizer': organizer,
'type': matchtype,
}
if match is None:
data['poolroom'] = poolroomid
data['status'] = 'approved'
newmatch = MatchForm(data)
else:
data['status'] = request.POST['status']
data['poolroom'] = poolroomid
newmatch = MatchForm(data=data, instance=match)
if newmatch.is_valid():
newmatch.save()
return HttpResponse(json.dumps({'rt': 1, 'msg': 'created'}), content_type="application/json")
return HttpResponse(json.dumps(dict({'rt': 0}.items() + newmatch.errors.items())), content_type="application/json")
from django.shortcuts import render, get_object_or_404, redirect
from django.views import generic
from django.http import HttpResponse
from .models import Post, UserPost, Hashtag, Shpion, ShpionFollowing, ShpionFollowingFollowers, BlackList, PostList, SecondaryUser
import requests
import datetime as dt
from django.conf import settings
import threading
import instaloader
from django.utils.timezone import pytz
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from bs4 import BeautifulSoup
zone = pytz.timezone(settings.TIME_ZONE)
def checkIP():
ip = requests.get('http://checkip.dyndns.org').content
soup = BeautifulSoup(ip, 'html.parser')
return soup.find('body').text
class LockedIterator(object):
def __init__(self, it):
self.lock = threading.Lock()
self.it = it.__iter__()
def __iter__(self):
return self
def handle(self, *args, **options):
dst_dir = SettingManager.get("root_dir")
src_dir = SettingManager.get("src_holter")
p = pathlib.Path(src_dir)
temp_dir = SettingManager.get("temp_dir")
# в каих каталогах искать "-" дней
back_days = SettingManager.get("holter_back_days")
d_start = datetime.now().date() - relativedelta(days=back_days)
today_dir = datetime.now().strftime('%Y/%m/%d')
# Ищем последовательность
pattern = re.compile('(Направление: <b>\d+</b>;)|(Адрес: <b>\d+</b>;)')
pattern_doc = re.compile('Врач')
# услуга относящаяся к подразделению
podrazdeleniye_pk = SettingManager.get("ofd")
podrazdeleniye_users = DoctorProfile.objects.values_list(
'pk', 'fio').filter(podrazdeleniye=podrazdeleniye_pk)
podrazdeleniye_manager_pk = SettingManager.get("manager_ofd")
pk_research = SettingManager.get("holter_pk_research")
user_timezone = pytz.timezone(TIME_ZONE)
datetime_object = datetime.strptime(
AFTER_DATE_HOLTER, '%Y-%m-%d %H:%M:%S').astimezone(user_timezone)
holter_obj, created = TempData.objects.get_or_create(
key='holter', defaults={"holter_protocol_date": datetime_object})
if created:
date_proto = TempData.objects.values_list(
'holter_protocol_date').get(key='holter')
date_proto = date_proto[0].astimezone(user_timezone)
else:
date_proto = holter_obj.holter_protocol_date
date_proto = date_proto.astimezone(user_timezone)
doctors = {}
for i in podrazdeleniye_users:
k = i[1].split()
temp_dict = {k[0]: i[0]}
doctors.update(temp_dict)
for f in p.iterdir():
stat_info = f.stat()
if datetime.fromtimestamp(stat_info.st_ctime) > datetime.combine(
d_start, datetime.min.time()):
for h in f.glob('*.html'):
find = False
stat_info = h.stat()
file_modify = datetime.fromtimestamp(
stat_info.st_mtime).astimezone(user_timezone)
holter_path_result = h.as_posix()
file_name = holter_path_result.split('/')[-1]
if stat_info.st_size > 30000 and file_modify > date_proto:
with open(holter_path_result, 'r',
encoding="cp1251") as file:
for line in file:
result = pattern.match(line)
if result:
obj_num_dir = re.search(
r'\d+', result.group(0))
num_dir = int(obj_num_dir.group(0))
if num_dir >= 4600000000000:
num_dir -= 4600000000000
num_dir //= 10
obj_iss = Issledovaniya.objects.filter(
napravleniye=num_dir,
research=pk_research).first()
if obj_iss:
time_confirm = obj_iss.time_confirmation
file_modify = datetime.fromtimestamp(
stat_info.st_mtime).astimezone(
user_timezone)
if obj_iss.time_confirmation:
delta_confirm = file_modify - time_confirm
if delta_confirm.seconds // 60 > SettingManager.get(
"holter_reset_confirm"):
break
patient = Napravleniya.objects.filter(
pk=num_dir).first()
fio = patient.client.get_fio_w_card()
if not os.path.exists(dst_dir +
today_dir):
new_dir = dst_dir + today_dir
os.makedirs(new_dir)
find = True
current_dir = os.path.dirname(
holter_path_result)
TempData.objects.filter(
key='holter'
).update(
holter_protocol_date=file_modify)
if os.path.exists(temp_dir):
rmtree(temp_dir)
copytree(current_dir, temp_dir)
if find:
with open(temp_dir + file_name,
'r',
encoding="cp1251") as f:
old_data = f.read()
new_data = old_data.replace(
'Адрес:', fio + '<br><u>Направление:</u>')
with open(temp_dir + file_name,
'w',
encoding="cp1251") as f:
f.write(new_data)
with open(temp_dir + file_name,
'r',
encoding="cp1251") as f:
find_doc = False
break_line = False
pk_doc = None
for line in f:
result = pattern_doc.search(line)
if result:
find_doc = True
if find_doc:
for doc in doctors.keys():
doc_fio_find = re.search(doc, line)
if doc_fio_find:
pk_doc = doctors.get(
doc_fio_find.group(0))
break_line = True
break
if break_line:
break
list_fio = fio.split()
link = today_dir + f'/{str(num_dir) + "_" + list_fio[2]}.pdf'
if sys.platform != 'win32':
try:
display = Display(visible=0,
size=(800, 600))
display.start()
pdfkit.from_file(temp_dir + file_name,
dst_dir + link)
finally:
display.stop()
else:
pdfkit.from_file(temp_dir + file_name,
dst_dir + link)
if pk_doc:
doc_profile = DoctorProfile.objects.filter(
pk=pk_doc).first()
else:
doc_profile = DoctorProfile.objects.filter(
pk=podrazdeleniye_manager_pk).first()
t = timezone.now()
obj_iss.doc_confirmation = doc_profile
if obj_iss.napravleniye:
obj_iss.napravleniye.qr_check_token = None
obj_iss.napravleniye.save(
update_fields=['qr_check_token'])
obj_iss.link_file = f'{today_dir}/{num_dir}_{list_fio[2]}.pdf'
obj_iss.time_confirmation = t
obj_iss.time_save = t
obj_iss.save(update_fields=[
'doc_confirmation', 'time_save',
'time_confirmation', 'link_file'
])
obj_iss.napravleniye.sync_confirmed_fields()
rmtree(temp_dir)
from tgBot.models import User, Time
from config import *
import requests
import json
import datetime
from tgBot.utils import to_main_page
from tgBot.controllers.users import proceed_invest
from django.utils.timezone import pytz, now as timezone_now
from tgBCoinBot.settings import TIME_ZONE
tz = pytz.timezone(TIME_ZONE)
def get_json_data(begin, end):
for i in range(0, 10):
try:
params = {
'account': payeer_account,
'apiId': payeer_api_id,
'apiPass': payeer_api_pass,
'action': 'history',
'type': 'incoming',
'from': begin.strftime('%Y-%m-%d %H:%M:%S'),
'to': end.strftime('%Y-%m-%d %H:%M:%S'),
}
# headers = {
# 'Content-Type': 'application/json'
# }
r = requests.post('https://payeer.com/ajax/api/api.php',
data=params)
data = r.text
from django.http import HttpResponse, JsonResponse
from django.shortcuts import render
# Create your views here.
# 首页
from django.utils.timezone import pytz
from corneredbeast.vincent.main import hiveToolkit
from corneredbeast.vincent.main.hiveToolkit import NewPhone
from corneredbeast.vincent.main.init_db import init_weidongurls
# ------------------------初始化方法开始------------------------#
# 初始化数据库
from corneredbeast.vincent.models import weidongurls
localtimezone = pytz.timezone('Asia/Shanghai')
def init_db(request):
init_weidongurls()
return HttpResponse("init_db has run")
# ------------------------初始化方法结束------------------------#
# ------------------------rtxspy开始------------------------#
def rtxspy(request):
return render(request, 'vincent/rtxspy.html')
import operator
import itertools
from copy import deepcopy
from functools import reduce
from datetime import timedelta, datetime, time, date
from django.utils.timezone import pytz
from django.db import models
from django.db.models import Q
from htravel import settings
from robot.helpers import TimeRange, get_next_saturday
from searcher.helpers import get_date_to
ROUTES_COUNT = 5
LOCAL_TZ = pytz.timezone(settings.TIME_ZONE)
class Country(models.Model):
title = models.CharField(max_length=50)
code = models.CharField(max_length=10)
def __str__(self):
return self.title
class City(models.Model):
title = models.CharField(max_length=50)
name = models.CharField(max_length=50)
descr = models.TextField(null=True, blank=True, default=None)
iata_code = models.CharField(max_length=3,
def get(request, item_name, item_id):
"""
Generate PDF from HTML template
"""
item = None
try:
if item_name == 'PC':
item = PC.objects.get(id=item_id)
except:
raise Http404('ERROR GeneratePdf:get')
tzkiev = pytz.timezone('Europe/Kiev')
context = {
'user_first_name':
request.user.first_name,
'user_last_name':
request.user.last_name,
'current_time':
datetime.now(tzkiev).strftime("%d/%m/%Y %H:%M:%S"),
'item_id':
item.id,
'item_name':
item.name,
'item_name_for_user':
item.name_for_user,
'item_inventory_number':
item.inventory_number,
'item_floor':
item.floor,
'item_room':
item.room,
'item_place':
item.place,
'item_operating_system':
item.operating_system,
# 'item_text_field': item.text_field if item.text_field else None,
'item_motherboard_brand':
item.motherboard.brand if item.motherboard else None,
'item_motherboard_model':
item.motherboard.model if item.motherboard else None,
'item_motherboard_serial_number':
item.motherboard.serial_number if item.motherboard else None,
'item_motherboard_form_factor':
item.motherboard.form_factor if item.motherboard else None,
'item_motherboard_type_ram_slot':
item.motherboard.type_ram_slot if item.motherboard else None,
'item_motherboard_central_processing_unit':
item.motherboard.central_processing_unit
if item.motherboard else None,
'item_motherboard_integrated_graphics':
item.motherboard.integrated_graphics if item.motherboard else None,
'item_motherboard_integrated_sound_card':
item.motherboard.integrated_sound_card
if item.motherboard else None,
'item_motherboard_integrated_lan_card':
item.motherboard.integrated_lan_card if item.motherboard else None,
'item_solid_state_drive_brand':
item.solid_state_drive.brand if item.solid_state_drive else None,
'item_solid_state_drive_model':
item.solid_state_drive.model if item.solid_state_drive else None,
'item_solid_state_drive_serial_number':
item.solid_state_drive.serial_number
if item.solid_state_drive else None,
'item_solid_state_drive_memory_size':
item.solid_state_drive.memory_size
if item.solid_state_drive else None,
'item_hard_disk_drive_brand':
item.hard_disk_drive.brand if item.hard_disk_drive else None,
'item_hard_disk_drive_model':
item.hard_disk_drive.model if item.hard_disk_drive else None,
'item_hard_disk_drive_serial_number':
item.hard_disk_drive.serial_number
if item.hard_disk_drive else None,
'item_hard_disk_drive_memory_size':
item.hard_disk_drive.memory_size if item.hard_disk_drive else None,
'item_power_supply_brand':
item.power_supply.brand if item.power_supply else None,
'item_power_supply_model':
item.power_supply.model if item.power_supply else None,
'item_power_supply_serial_number':
item.power_supply.serial_or_inventory_number
if item.power_supply else None,
'item_power_supply_power_consumption':
item.power_supply.power_consumption if item.power_supply else None,
'item_video_card_brand':
item.video_card.brand if item.video_card else None,
'item_video_card_model':
item.video_card.model if item.video_card else None,
'item_video_card_serial_number':
item.video_card.serial_number if item.video_card else None,
'item_video_card_memory_size':
item.video_card.memory_size if item.video_card else None,
'item_lan_card_brand':
item.lan_card.brand if item.lan_card else None,
'item_lan_card_model':
item.lan_card.model if item.lan_card else None,
'item_lan_card_serial_number':
item.lan_card.serial_number if item.lan_card else None,
'item_sound_card_brand':
item.sound_card.brand if item.sound_card else None,
'item_sound_card_model':
item.sound_card.model if item.sound_card else None,
'item_sound_card_serial_number':
item.sound_card.serial_number if item.sound_card else None,
'item_optical_drive_brand':
item.optical_drive.brand if item.optical_drive else None,
'item_optical_drive_model':
item.optical_drive.model if item.optical_drive else None,
'item_optical_drive_serial_number':
item.optical_drive.serial_number if item.optical_drive else None,
'item_optical_drive_type_drive':
item.optical_drive.type_drive if item.optical_drive else None,
'item_optical_drive_type_connector':
item.optical_drive.type_connector if item.optical_drive else None,
}
template = 'IT_items/invoice.html'
pdf = render_to_pdf(template, context)
if pdf:
filename = '{}_#_{}_floor_{}_room_{}.pdf'.format(
item.name, item.inventory_number, item.floor, item.room)
content = 'inline; filename="{}"'.format(filename)
if request.GET.get('save_to_file') == 'true':
content = 'attachment; filename="{}"'.format(filename)
response = HttpResponse(pdf, content_type='application/pdf')
response['Content-Disposition'] = content
return response
return HttpResponse(status=404)