def image_upload(request):
# 저장할 db 호출
speak = Speaking()
# 전송받은 파일 저장
speak.image = request.FILES['inputImage']
speak.cap_text = 'test'
speak.save()
# 이미지 캡셔닝 모델 실행
text = speak.image
return_text = caption.main(text)
# 기능 이용 카운트를 추가
user = request.user
today = DateFormat(datetime.now()).format('Y-m-d')
# 테이블에서 해당하는 오브젝트를 가져옴
day = get_object_or_404(DateCount, user=user, date=today)
# 해당하는 기능에 카운트를 +1 하고 저장한다
day.image_speak_count += 1
day.save()
# 결과물 전송
return Response(return_text)
def check(request, id):
data = tbnoti.objects.get(id=id)
data.status = "Accept"
data.seen = "YES"
userid = data.sentid
data.save()
petid = data.arg1
trainerid = request.session['trainerid']
if request.method == "POST":
date = request.POST.get("date")
dt = datetime.now()
df = DateFormat(dt)
datenow = df.format('d-m-Y')
amount = request.POST.get('amount')
duration = request.POST.get('duration')
days = request.POST.get('days')
handlerid = request.POST.get("handler")
descriptions = datenow + " Trainer Accepted user Requested and Add requested user to deliver his dog on or befor " + date + '/n'
data = tbonuser.objects.create(descriptions=descriptions,
usersid=userid,
petid=petid,
varid=trainerid,
date=date,
status="You can send your pet please",
handler=handlerid,
amount=amount,
days=days,
duration=duration)
handlers = tbhandlers.objects.get(name=handlerid)
handlers.assigments = "yes"
handlers.dogid = petid
handlers.save()
return HttpResponseRedirect(reverse('trainerapp:demotrainer'))
def check(request, id):
data = tbnoti.objects.get(id=id)
data.status = "Accept"
data.seen = "YES"
userid = data.sentid
data.save()
recid = data.recid
petid = data.arg1
boardingid = request.session['boardingid']
if request.method == "POST":
date = request.POST.get("date")
dt = datetime.now()
df = DateFormat(dt)
datenow = df.format('d-m-Y')
amount = request.POST.get('amount')
descriptions = datenow + " Bordings Accepted user Requested and Add requested user to deliver his/n"
data1 = tbonuser.objects.create(descriptions=descriptions,
usersid=userid,
petid=petid,
varid=boardingid,
date=date,
status="You can send your pet",
amount=amount,
handler="",
duration="",
days="")
return HttpResponseRedirect(reverse('boardingapp:demoboarding'))
def demoapp(request):
pet=tbpets.objects.all()
for i in pet:
dob=datetime.strptime(i.dob,'%Y-%m-%d')
vaccdat=datetime.strptime(i.Vdate,'%Y-%m-%d')
dt = datetime.now()
df = DateFormat(dt)
date=df.format('d-m-Y')
nowdate=datetime.strptime(date,'%d-%m-%Y')
balance=nowdate-dob
mm=balance/365
i.age=mm.days
nan=vaccdat-nowdate
i.bal=nan.days
i.save()
try:
myid=request.session['userid']
except:
try:
myid=request.session['trainerid']
except:
try:
myid=request.session['boardingid']
except:
return render(request,'app/demoapp.html',{})
if myid:
cartc=tbcart.objects.filter(userid=myid).count()
data=tbboarlog.objects.get(id=myid)
return render(request,'app/demoapp.html',{'cartc':cartc,'data':data})
return render(request,'app/demoapp.html',{})
def post(self, request, *args, **kwargs):
article_id = self.request.POST.get("article_id")
comment = self.request.POST.get("comment")
article = Article.objects.get(pk=article_id)
new_comment = article.comments.create(author=request.user, content=comment)
likes_count = new_comment.get_likes()
dislikes_count = new_comment.get_dislikes()
dt = datetime.now()
df = DateFormat(dt)
tf = TimeFormat(dt)
new_comment_timestamp = (
df.format(get_format("DATE_FORMAT"))
+ ", "
+ tf.format(get_format("TIME_FORMAT"))
)
data = [
{
"author": new_comment.author.get_full_name(),
"comment": new_comment.content,
"comment_id": new_comment.pk,
"comment_likes": likes_count,
"comment_dislikes": dislikes_count,
"timestamp": new_comment_timestamp,
"slug": article.slug,
}
]
return JsonResponse(data, safe=False)
def userinfo(request): # mypage 시작
today = DateFormat(datetime.now()).format(
'Ymd') # 현재 시간을 Ymd 포멧으로 today에 저장 Ex) 2020-08-01
conn_user = request.user # 현재 접속중인 유저를 conn_user에 저장
conn_profile = Profile.objects.get(
user=conn_user) # Profile models에서 현재 접속중인 유저의 정보를 conn_porfile에 저장
timesave = Timesave.objects.filter(
input_date=today, save_user_id=conn_user
) # Timesave models에서 그리고 현재 접속중인 유져의 today값을 가져옴
sum = Timesave.objects.filter(
input_date=today, save_user_id=conn_user).aggregate(
Sum('save_date')) # today의 시간을 모두 더해서 sum 변수에 담아줌
values = sum.values() # sam은 딕셔너리 타입이라 values만 따로 가져옴
for i in values: # 딕셔너리의 values를 for문을 돌려 따로따로 i에 저장함 < 좀어렵
continue
context = { # 모든 값을 context에 저장
'id' : conn_user.username,
'nick' : conn_profile.nick,
'birth_date' : conn_profile.birth_date,
'timesave' : timesave,
'plan' : conn_profile.plan,
'sum' : i,
}
return render(request, 'mypage.html',
context=context) # context값과 함께 mypage.html을 호출
def get_group_info(request, group_id, avatar_size=GROUP_AVATAR_DEFAULT_SIZE):
group = seaserv.get_group(group_id)
try:
avatar_url, is_default, date_uploaded = api_grp_avatar_url(
group.id, avatar_size)
except Exception as e:
logger.error(e)
avatar_url = get_default_group_avatar_url()
val = utc_to_local(dt(group.timestamp))
group_info = {
"id":
group.id,
"name":
group.group_name,
"creator":
group.creator_name,
"created_at":
val.strftime("%Y-%m-%dT%H:%M:%S") + DateFormat(val).format('O'),
"avatar_url":
request.build_absolute_uri(avatar_url),
"admins":
get_group_admins(group.id),
}
return group_info
def edit_ok(request):
user = request.user
profile = Profile.objects.get(user=user)
if request.method=="POST":
category = request.POST.get('itemcd', None)
order_num = request.POST.get('ordno', None)
post_title = request.POST.get('subject', None)
post_content = request.POST.get('contents', None)
person_name = profile.person_name
try:
image = request.FILES['file[]']
except: image = "no_image"
create_date = DateFormat(datetime.now()).format('Y-m-d')
print(category,order_num,post_title,post_content,person_name,image,create_date)
# update query
cs = CustomerService.objects.get(post_title=post_title)
cs.category = category
cs.order_num=order_num
cs.post_content=post_content
cs.image=image
cs.create_date=create_date
try:
cs.save()
except Exception as e:
print(e)
return redirect('/customer_service/customer_page')
def write_nt(request):
if request.method=='POST':
category = request.POST.get('itemcd', None)
hit = 0
title = request.POST.get('subject', None)
content = request.POST.get('contents', None)
person_name = '관리자'
create_date = DateFormat(datetime.now()).format('Y-m-d')
print(category,hit,title,content,person_name,create_date)
nt = Notice(
category=category,
hit=hit,
title=title,
content=content,
person_name=person_name,
create_date=create_date,
)
try:
nt.save()
except Exception as e:
print(e)
return redirect('/customer_service/notice_page')
return render(request, "customer_service/notice_write.html")
def handle(cls, args, text):
if "format" in args:
format_string = args["format"]
else:
format_string = "Y.m.d H:i:s"
df = DateFormat(datetime.datetime.now())
return df.format(format_string)
def info_form(request):
# data = request.POST
date = DateFormat(datetime.now()).format('Y-m-d') #오늘 날짜만 가져오기
if request.method == "POST":
dict = request.POST.dict()
dogda_birth = request.POST.get('dogda_birth')
print(dogda_birth)
dict["reg_date"] = date
dict["dogda_birth"] = dogda_birth.replace("-", "")
print(dict)
form = Dogda_infoForm(dict)
if form.is_valid():
dogda_info = form.save(commit=False)
dogda_info.save()
return HttpResponseRedirect("/info")
else:
logger = logging.getLogger('')
logger.error('로그찍기')
return render(request, 'info/info_form.html')
def get(self, request, format=None, **kwargs):
"""
Return a list of all sales.
"""
if self.request.GET.get('date'):
date = self.request.GET.get('date')
summary = Item.objects.filter(created__icontains=date).values('product_name',
'product_category').annotate(
c=Count('product_name', distinct=True)) \
.annotate(Sum('total_cost')) \
.annotate(Sum('total_purchase')) \
.annotate(Sum('quantity')).order_by('-quantity__sum')
else:
date = DateFormat(datetime.datetime.today()).format('Y-m-d')
summary = Item.objects.filter(created__icontains=date) \
.values('product_name', 'product_category').annotate(
c=Count('product_name', distinct=True)) \
.annotate(Sum('total_cost')) \
.annotate(Sum('total_purchase')) \
.annotate(Sum('quantity')).order_by('-quantity__sum')
total_sale = 0
total_cost = 0
result = {}
for sale in summary:
total_sale += sale['total_cost__sum']
total_cost += sale['total_purchase__sum']
result['total_cost'] = total_cost
result['total_sale'] = total_sale
result['margin'] = total_sale - total_cost
return Response(result)
def add_process(request):
expense_type = request.POST.get('expense_type')
expense_date = DateFormat(datetime.datetime.today()).format('Y-m-d')
amount = request.POST.get('amount')
if request.user.name:
authorized_by = request.user.name
else:
authorized_by = request.user.email
paid_to = request.POST.get('paid_to')
description = request.POST.get('description')
new_expense = Expenses(expense_type=expense_type,
expense_date=expense_date,
amount=amount,
authorized_by=authorized_by,
paid_to=paid_to,
description=description)
petty_cash = PettyCash.objects.latest('id')
petty_cash_amount = petty_cash.closing
try:
petty_cash_amount -= Decimal(amount)
petty_cash.closing = petty_cash_amount
petty_cash.save()
user_trail(
request.user.name,
'spent KShs. ' + str(amount) + 'on ' + str(expense_type) +
' from petty cash, balance is: ' + str(petty_cash.closing))
except Exception, e:
error_logger.error(e)
def get_data(cls, activity):
from inspect import currentframe, getframeinfo
data = super(AddDealActionCommentForm, cls).get_data(activity)
if False:
a_feedback = A_Feedback.objects.filter(fk_activity=activity)
else:
frameinfo = getframeinfo(currentframe())
print('*** feedback not yet implemented! ', frameinfo.filename,
frameinfo.lineno)
a_feedback = []
if len(a_feedback) > 0:
feedback = a_feedback[0]
data.update({
"assign_to_user": feedback.fk_user_assigned.id,
"tg_feedback_comment": feedback.comment,
})
if False:
fully_updated_history = Activity.objects.get_fully_updated_history(
activity.activity_identifier)
else:
frameinfo = getframeinfo(currentframe())
print('*** fully updated history not yet implemented! ',
frameinfo.filename, frameinfo.lineno)
fully_updated_history = []
fully_updated = []
for h in fully_updated_history:
fully_updated.append("%s - %s: %s" % (DateFormat(
h.fully_updated).format("Y-m-d H:i:s"), h.username, h.comment))
data.update({"fully_updated_history": "\n".join(fully_updated)})
return data
class NewAppointmentForm(forms.Form):
dt = datetime.now() + timedelta(days=1)
df = DateFormat(dt)
#get clinics
results = java_Clinic_services.service.returnAllClinics()
clinic_choices = [(i.clinicid, i.clinicType + ' ('+i.clinicName + ') ' ) for i in results]
patientName = forms.CharField(label='Όνομα', max_length=100, required=True, widget=forms.TextInput(attrs={'class':'disabled', 'readonly':'readonly'}))
patientSurname = forms.CharField(label='Επώνυμο', max_length=100, required=True, widget=forms.TextInput(attrs={'class':'disabled', 'readonly':'readonly'}))
AMKA = forms.IntegerField(label='ΑΜΚΑ', required=True, widget=forms.TextInput(attrs={'class':'disabled', 'readonly':'readonly'}))
diseaseDetails = forms.CharField(label='Ποιό είναι το πρόβλημα σας', max_length=100, required=True)
clinicid = forms.ChoiceField(label='Κλινική', required=True, choices=clinic_choices)
insuranceFund = forms.CharField(label='Ασφάλεια', max_length=100, required=True)
appointmentDate = forms.DateField(label="Ημερομηνία", required=True, input_formats=['%d/%m/%Y'],
initial=df.format('d/m/Y'))
appointmentTime = forms.TimeField(label="Ώρα", required=True, input_formats=['%H:%M'], initial=df.format('H:i'))
appointmentEmergency = forms.ChoiceField(label='Είδος Ραντεβού', required=True, choices=EMERGENCY_CHOICES)
#with the following code we set the initial values from the 'patient' argument
def __init__(self, *args, **kwargs):
patient = kwargs.pop('patient')
super(NewAppointmentForm, self).__init__(*args, **kwargs)
self.fields['patientName'].initial=patient.patientName
self.fields['patientSurname'].initial=patient.patientSurname
self.fields['AMKA'].initial=patient.AMKA
self.fields['insuranceFund'].initial=patient.insuranceFund
def fancy_date(self, datelist):
fancydates = []
for d in datelist:
t = datetime.strptime(d, '%Y-%m-%d')
date = self.ucfirst(DateFormat(t).format('l j'))
fancydates.append(date)
return ', '.join(fancydates)
def reviews(request, book_id, user_id):
detailurl = request.build_absolute_uri(
reverse('books:detail', args=[book_id]))
if request.method == 'POST':
review_form = ReviewForm(request.POST)
print(review_form.errors)
if review_form.is_valid():
date = DateFormat(datetime.now()).format(get_format('DATE_FORMAT'))
review = review_form.cleaned_data['review']
rating = review_form.cleaned_data['rating']
book = Book.objects.get(pk=book_id)
reviewer = request.user
new_review = Review(date=date,
review=review,
rating=rating,
reviewed_book=book,
reviewer=reviewer)
new_review.save()
return HttpResponseRedirect(detailurl)
else:
review_form = ReviewForm()
return render(request, 'books/review_book.html', {
'detailurl': detailurl,
'review': review_form
})
def post(self, request):
AWS_S3_CREDS = {
"aws_access_key_id" : AWS_S3_ACCESS_KEY_ID,
"aws_secret_access_key": AWS_S3_SECRET_ACCESS_KEY
}
s3_client = boto3.client('s3', **AWS_S3_CREDS)
files = request.FILES.getlist('fileNames')
if not files:
return JsonResponse({'message': 'IMAGE_DOES_NOT_EXIST'}, status=400)
file_urls = []
for file in files:
file_type = file.content_type.split('/')[-1]
file_name = str(uuid.uuid4()).replace('-','') + DateFormat(datetime.now()).format('Ymd')+ '.' + file_type
s3_client.upload_fileobj(
file,
AWS_S3_STORAGE_BUCKET_NAME,
file_name,
ExtraArgs={
"ContentType": file.content_type
}
)
file_urls.append(f"https://{AWS_S3_STORAGE_BUCKET_NAME}.s3.ap-northeast-2.amazonaws.com/{file_name}")
return JsonResponse({'file_urls': file_urls}, status=200)
def get_sure_month_bill(date=None) -> BillModel:
"""
获取准确的月份（由发薪日控制）
:param date: date类型时间
:return: 对应时间的总账
"""
if not date:
date = localdate()
day = DateFormat(date).j()
salary_day = salary_day_with_week_day(date)
# 特殊的月份
special_month = [2]
if date.month not in special_month and day < salary_day:
date = date - relativedelta(months=1)
result = BillModel.objects.filter(date__year=date.year,
date__month=date.month)
if result.exists():
return result.first()
raise ModuleNotFoundError("次月账单没有维护，请前往admin页签维护后使用")
else:
bill_id = BillModel.objects.filter(
date__gte=date).order_by('date').first()
if not bill_id:
return BillModel.objects.first()
return bill_id
def __str__(self):
fstr = '{} for {} deposited on {}'.format(
self.name, self.amount,
DateFormat(self.date).format('F jS, Y'))
if self.account_number:
fstr += ' into account #{}'.format(self.account_number)
return fstr
def f_datetime(self, f):
"""
Display date and time according to settings
:param f:
:return:
"""
return DateFormat(f).format(config.date_time_formats.datetime_format)
def create_coursecomment(request, id):
# if the comment is not null
if not 'commentArea' in request.POST or not request.POST['commentArea']:
context = json.dumps({"message": "error"})
return HttpResponse(context, content_type='application/json')
course = Course.objects.get(course_id=id)
user = request.user
new_comment = CourseComment(text=request.POST['commentArea'],
user=user,
Course=course)
new_comment.save()
df = DateFormat(localtime(new_comment.time))
date = df.format(get_format('DATE_FORMAT'))
time = df.format('f a')
timestamp = date + ", " + time
firstname = user.first_name
lastname = user.last_name
userid = user.id
# convert into json format
context = json.dumps({
"commentText": request.POST['commentArea'],
"firstname": firstname,
"time": timestamp,
"lastname": lastname,
"userid": userid
})
# return json ajax
return HttpResponse(context, content_type='application/json')
def skill_list(request):
#skill_list = OfferSkills.objects.using("mysql").all().values('skill_name').annotate(total=Count('skill_name')).order_by('-total')
#paginator = Paginator(skill_list, 20)
date = request.GET.get('date')
if date == None:
date = DateFormat(datetime.now()).format('Ymd')
sql_params = [date]
print(date)
sql = """
select skill_name, count(skill_name) total
from offer_skills
where DATE_FORMAT(created, "%%Y%%m%%d") = %s
group by skill_name
order by total desc
"""
cursor = connections['mysql'].cursor()
cursor.execute(sql, sql_params)
paginator = Paginator(dictfetchall(cursor), 20) # 페이지당 20개씩 출력
page = request.GET.get('page')
try:
contacts = paginator.page(page)
except PageNotAnInteger:
# page가 숫자가 아닐 경우 첫 페이지로 이동
contacts = paginator.page(1)
except EmptyPage:
# 페이지가 없을 경우 마지막 페이지로 이동
contacts = paginator.page(paginator.num_pages)
return render(request, 'offerstate/states_list.html', {"list":contacts})
def ping_response(self, obj):
interval = settings.JOB_RUNNER_WORKER_PING_INTERVAL
margin = settings.JOB_RUNNER_WORKER_PING_MARGIN
if not obj.ping_response_dts:
return '<span style="color: red;">(none)</span>'
date_local = obj.ping_response_dts.astimezone(
timezone.get_current_timezone())
date_formatted = DateFormat(date_local)
date_formatted = date_formatted.format(settings.DATETIME_FORMAT)
if not obj.is_responsive():
return ('<img src="{0}admin/img/icon_error.gif" /> '
'<span style="color: red;">{1}</span>'.format(
settings.STATIC_URL, date_formatted))
if (obj.ping_response_dts <
timezone.now() - timedelta(seconds=interval + margin)):
return ('<img src="{0}admin/img/icon_alert.gif" /> '
'<span style="color: orange;">{1}</span>'.format(
settings.STATIC_URL, date_formatted))
return ('<img src="{0}admin/img/icon_success.gif" /> '
'<span style="color: green;">{1}</span>'.format(
settings.STATIC_URL, date_formatted))
def test_last_known_activity_time(self):
someone_else = user_factory(username='******')
addon = addon_factory()
model_admin = UserAdmin(UserProfile, admin.site)
assert str(model_admin.last_known_activity_time(self.user)) == ''
# Add various activities. They will be attached to whatever user is
# set in the thread global at the time, so set that in advance.
core.set_user(self.user)
expected_date = self.days_ago(1)
activity = ActivityLog.create(amo.LOG.CREATE_ADDON, addon)
activity.update(created=self.days_ago(2))
activity.userlog_set.update(created=self.days_ago(2))
activity = ActivityLog.create(amo.LOG.EDIT_PROPERTIES, addon)
activity.update(created=expected_date)
activity.userlog_set.update(created=expected_date)
assert activity.reload().created == expected_date
# Create another activity, more recent, attached to a different user.
core.set_user(someone_else)
activity = ActivityLog.create(amo.LOG.EDIT_PROPERTIES, addon)
expected_result = DateFormat(expected_date).format(
settings.DATETIME_FORMAT)
assert (
str(model_admin.last_known_activity_time(self.user)) ==
expected_result)
def on_notification_post_save(sender, created, **kwargs):
if created:
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
notification = kwargs['instance']
recipient = notification.notified_user
sessionid = redis_client.get(recipient.id)
print "Recipient: %s" % recipient.id
if sessionid:
# for session in recipient.session_set.all():
datetime.timedelta(0, 5, 30)
t = notification.time_of_creation
t = t + datetime.timedelta(hours=5, minutes=30)
t = DateFormat(t).format('N j, Y, P')
t = str(t)
# t = t[:-13]
notifier_name = notification.notifier.first_name + " " + notification.notifier.last_name
print " notifier name = ", notifier_name
redis_client.publish(
'notifications.%s' % sessionid,
json.dumps(
dict(timestamp=t,
recipient=notification.notified_user.id,
actor=notifier_name,
verb=notification.notification_type,
action_object=notification.notification_media,
notification_id=notification.id)))
def get(self, request, format=None):
#Latest tour used for the total number of riders
tour = TourConfig.objects.latest('pk') # Get the latest tour
df = DateFormat(datetime.now())
end_interval = long(df.U())
poll_rate = tour.server_polling_rate
poll_range = tour.server_polling_range
#Sever's poling range+polling interval ago.
start_interval = end_interval - poll_rate -poll_range
rider_count = Rider.objects.count()
riders = {}
cursor = connection.cursor()
cursor.execute(
"""SELECT DISTINCT ON(rider_id) rider_id, speed, ST_X(coords), ST_Y(coords)
FROM location_update_location
WHERE time BETWEEN %s AND %s LIMIT %s""",
[start_interval, end_interval, rider_count])
for row in cursor.fetchall():
(rider_id, speed, lon, lat)=row
if not riders.has_key(rider_id):
riders[rider_id] = []
riders[rider_id].append((int(speed), lon, lat))
riders = riders.values()
return Response(
{'locations': riders}, status=status.HTTP_200_OK)
def get_formatted_date(self, format_time='d/m/Y'):
# Correct date and format
localised_date = self.timestamp
if not settings.DEBUG:
localised_date = localised_date - timedelta(hours=6)
return DateFormat(localised_date).format(format_time)
def post(self, request, *args, **kwargs):
user = self.request.user
if user.is_authenticated:
profile = Profile.objects.filter(user=user).get()
order_number = str(DateFormat(datetime.now()).format('Ymd')) + str(user.pk) + str(randint(1000, 9999))
return Response({
"detail":
{
"email": user.username,
"username": user.nickname,
"phone": profile.phone,
"order_num": order_number
}
}, status=status.HTTP_200_OK)
# class Test(APIView):
# def post(self, request, *args, **kwargs):
# search_tag = SearchTag.objects.all()
#
# for i in search_tag:
# tags = Tag.objects.create(tags=i.tag)
# i.post.tags.add(tags)
#
# return Response({
# "success"
# }, status=status.HTTP_200_OK)
def vocabulary(request):
# 선택한 필드가 'True'인 단어 중에서 랜덤으로 20개 선정
if 'Toeic' in request.data:
vocas = Vocabulary.objects.filter(Toeic=True).order_by('?')[0:20]
elif 'Opic' in request.data:
vocas = Vocabulary.objects.filter(Opic=True).order_by('?')[0:20]
elif 'korean_SAT' in request.data:
vocas = Vocabulary.objects.filter(korean_SAT=True).order_by('?')[0:20]
# 오늘 날짜를 함께 기록
today = DateFormat(datetime.now()).format('Y-m-d')
serializer = VocabularySerializer(vocas, many=True)
# 날짜와 단어장을 함께 전송
data = {"today": today, "vocabulary": serializer.data}
# 기능 이용 카운트를 추가
# 요청 보낸 유저 및 날짜에 맞는 테이블 체크
user = request.user
# DateCount.objects.filter()의 형태로 가져올 경우,
# object가 아니라 QuerySet으로 가져옴
# QuerySet 보다 object로 가져올 경우 수정이 쉽다
day = get_object_or_404(DateCount, user=user, date=today)
# 해당하는 기능에 카운트를 +1 하고 저장한다
day.vocabulary_count += 1
day.save()
return Response(data)
