def run(self, data=None):
# Wait for data
loop = asyncio.get_event_loop()
t = asyncio.ensure_future(self.wait_for_data(timeout=30))
loop.run_until_complete(t)
loop.close()
response = t.result()
if response:
sender = '*****@*****.**'
receivers = ['*****@*****.**']
message = 'From: From Person <*****@*****.**>\n' \
'To: To Person <*****@*****.**>\n' \
'Subject: Rule Engine Notification\n\n' \
'Data:' + str(response) + '\n' \
'Sent by Rule Engine. Scenario:1.'
self.send_email(host='smtp.gmail.com',
port=587,
username="******",
password="******",
sender=sender,
receivers=receivers,
message=message)
# Wait 10 milliseconds
time.sleep(10)
api = KavenegarAPI('Your APIKey')
params = {
# optional
'sender': '',
# multiple mobile number, split by comma
'receptor': '09390909540',
'message': 'helloooo',
}
api.sms_send(params)
class KavenegarBackend(BaseBackend):
def __init__(self, **options):
super().__init__(**options)
# Lower case it just to be sure
options = {key.lower(): value for key, value in options.items()}
self.api_key = options.get("secret", None)
self.sender = options.get("from", None)
self.client = KavenegarAPI(self.api_key)
self.exception_class = APIException, HTTPException
def send_sms(self, number, message):
params = {
'sender': self.sender,
'receptor': number,
'message': message,
}
self.client.sms_send(params)
def send_bulk_sms(self, numbers, message):
params = {
'sender': self.sender,
'receptor': numbers,
'message': message,
}
self.client.sms_sendarray(params)
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
user.ConfirmedOtp = False
user.save()
login(request, user)
#Generate OTP for request.user
OTP = randint(100000,999999)
c = ActivatedCode.objects.create(user=user,
code= OTP
)
c.save()
print('code sended to :' + str(user.PhoneNumber) + '- & Code is:'+str(c))
#usign kaveh negar to send data
# kavenegar.com
try:
api = KavenegarAPI(
)
params = {
'sender': '',
'receptor': str(user.PhoneNumber),
'message': str(c.code),
}
response = api.sms_send(params)
print(response)
print('SENDED CODE : ' + str(c.code))
except Exception as e:
print(e)
return redirect('app:view')
def send_sms_kavenegar(token, phone_number, code):
api = KavenegarAPI(token)
params = {
'receptor': phone_number,
'token': code,
'template': 'SymptomCheckerVerify'
}
response = api.verify_lookup(params)
return response
def __init__(self, **options):
super().__init__(**options)
# Lower case it just to be sure
options = {key.lower(): value for key, value in options.items()}
self.api_key = options.get("secret", None)
self.sender = options.get("from", None)
self.client = KavenegarAPI(self.api_key)
self.exception_class = APIException, HTTPException
def send_sms(phone, code):
api = KavenegarAPI(KAVENEGAR_API)
# api.host="79.175.172.10"
# for OTP account
params = {
'receptor': phone,
'token': '%d' % code,
'type': 'sms',
'template': 'verifyasoude'
}
api.verify_lookup(params)
def send_verification_sms(phone, message):
api = KavenegarAPI(
'6652373751486A6D5A34584B476A466F346E616F7A313768553441726330554E')
params = {
'sender': '1000596446',
'receptor': phone,
'message': message.encode('utf-8')
}
try:
response = api.sms_send(params)
except:
print("شماره کاربر مشکل دارد")
def send():
try:
api = KavenegarAPI(
'706E46722F2B68762F7273766634694A66325A4F4A4A75622F33375346786C57586C706F6A596A697751493D'
)
params = {
'receptor': '09226255415',
'message': 'SMS WEB BASED API BY @pd',
}
response = api.sms_send(params)
print(response)
except Exception:
abort("503")
else:
return jsonify(response)
def MesssageSendingView(request, slug):
api = KavenegarAPI(
'30383967456C38706753473546583443536233774E374E6E702B5832386C7648')
if request.user.is_masteruser:
user_instance = get_object_or_404(UserModel, slug=slug)
sportclub_instance = get_object_or_404(SportClubModel,
user=user_instance)
if request.method == 'POST':
message_form = MessageForm(data=request.POST)
if message_form.is_valid():
message_text = message_form.cleaned_data.get('text')
params = {
'sender': '10008000300010',
'receptor': sportclub_instance.phone_number,
'message': message_text
}
response = api.sms_send(params)
masteruser_instance = get_object_or_404(UserModel,
slug=request.user.slug)
masteruser_instance_logs = masteruser_instance.user_logs
now = jdatetime.datetime.now()
dtime = str(now.year) + '-' + str(now.month) + '-' + str(
now.day) + ' ' + str(now.hour) + ':' + str(
now.minute) + ':' + str(now.second)
new_log = '''{previous_logs}\n
On {date_time}:\n
Sent a Message to: {user} (Sport Club)\n
Message:\n
{message}
-------------------------------------------------------
'''.format(
previous_logs=masteruser_instance_logs,
date_time=dtime,
user=str(sportclub_instance.user.username),
message=str(message_text),
)
masteruser_instance.user_logs = new_log
masteruser_instance.save()
return HttpResponseRedirect(
reverse('masteruser:workspace',
kwargs={'slug': request.user.slug}))
else:
message_form = MessageForm()
return render(request, 'sportclub/messageform.html', {
'form': message_form,
})
def run(self, data=None):
v = self.redis.get("Her")
if v is None:
self.redis.set("Her", 0)
else:
self.redis.set("Her", int(v) + 1)
api = KavenegarAPI('Your APIKey')
params = {
# optional
'sender': '',
# multiple mobile number, split by comma
'receptor': '09390909540',
'message': str(v),
}
api.sms_send(params)
def test_send_sms_to_one_person(self):
try:
api = KavenegarAPI(
'51474735396C536947576930554D724332327075506E78667532482B58462B71672B5A7148554E753939733D',
)
params = {
# 'sender': '1000596446', # optional
'receptor': self.user.phone, # multiple mobile number, split by comma
'message': 'notif.title' + '\n\n' + 'notif.description' + '\n\n' + 'Nilva team',
}
response = api.sms_send(params)
print(response)
except APIException as e:
print(e) # for example running out of balance
except HTTPException as e:
print(e)
def MesssageSendingView(request, slug):
api = KavenegarAPI(settings.KAVENEGAR_API_KEY)
if request.user.is_masteruser:
user_instance = get_object_or_404(UserModel, slug=slug)
commonuser_instance = get_object_or_404(CommonUserModel,
user=user_instance)
if request.method == 'POST':
message_form = MessageForm(data=request.POST)
if message_form.is_valid():
message_text = message_form.cleaned_data.get('text')
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': commonuser_instance.user.username,
'message': message_text
}
response = api.sms_send(params)
masteruser_instance = get_object_or_404(UserModel,
slug=request.user.slug)
masteruser_instance_logs = masteruser_instance.user_logs
now = jdatetime.datetime.now()
dtime = str(now.year) + '-' + str(now.month) + '-' + str(
now.day) + ' ' + str(now.hour) + ':' + str(
now.minute) + ':' + str(now.second)
new_log = '''{previous_logs}\n
On {date_time}:\n
Sent a message to: {user} (Common User)\n
Message:\n
{message}
-------------------------------------------------------
'''.format(
previous_logs=masteruser_instance_logs,
date_time=dtime,
user=str(commonuser_instance.user.username),
message=str(message_text),
)
masteruser_instance.user_logs = new_log
masteruser_instance.save()
return HttpResponseRedirect(reverse('commonuser:list'))
else:
message_form = MessageForm()
return render(request, 'commonuser/messageform.html', {
'form': message_form,
})
def verify_call(self, reciever, code):
sms = self.create(reciever=reciever)
try:
api = KavenegarAPI(settings.KAVENEGAR_API_CODE)
params = {
'receptor': reciever,
'template': 'verify',
'token': code,
'type': 'call', # sms vs call
}
sms.response = api.verify_lookup(params)
sms.save()
except APIException as e:
print(e)
except HTTPException as e:
print(e)
def MesssageSendingView(request, slug):
api = KavenegarAPI(
'30383967456C38706753473546583443536233774E374E6E702B5832386C7648')
if request.user.is_masteruser:
user_instance = get_object_or_404(UserModel, slug=slug)
commonuser_instance = get_object_or_404(CommonUserModel,
user=user_instance)
if request.method == 'POST':
message_form = MessageForm(data=request.POST)
if message_form.is_valid():
message_text = message_form.cleaned_data.get('text')
params = {
'sender': '100065995',
'receptor': commonuser_instance.phone_number,
'message': message_text
}
response = api.sms_send(params)
masteruser_instance = get_object_or_404(UserModel,
slug=request.user.slug)
masteruser_instance_logs = masteruser_instance.user_logs
new_log = '''{previous_logs}\n
On {date_time}:\n
Sent a message to: {user} (Common User)\n
Message:\n
{message}
-------------------------------------------------------
'''.format(
previous_logs=masteruser_instance_logs,
date_time=timezone.localtime(timezone.now()),
user=str(commonuser_instance.user.username),
message=str(message_text),
)
masteruser_instance.user_logs = new_log
masteruser_instance.save()
return HttpResponseRedirect(
reverse('commonuser:detail',
kwargs={'slug': commonuser_instance.user.slug}))
else:
message_form = MessageForm()
return render(request, 'commonuser/messageform.html', {
'form': message_form,
})
def send_welcoming_message(username):
try:
user = User.objects.filter(username=username).first()
try:
api = KavenegarAPI(KAVENEGAR_API)
params = {
'sender': '1000596446',
'receptor': user.phone_number,
'message': 'خوش امدید\nپروفایل شما با موفقیت ساخته شد'
}
response = api.sms_send(params)
print(response)
except APIException as e:
print(e)
except HTTPException as e:
print(e)
except User.DoesNotExist:
return None
def CancellingBySportclubView(request, pk):
try:
today = jdatetime.datetime.now().date()
now_time = datetime.datetime.now().time()
booking_object = get_object_or_404(BookingModel, pk=pk)
session = booking_object.session
final_price = booking_object.final_price
if booking_object.session.day == today and booking_object.session.time < now_time or booking_object.session.day < today:
return HttpResponseRedirect(reverse('booking:cancellingerror'))
else:
session.is_booked = False
session.is_ready = False
session.booker = None
contract_discount = booking_object.contract_discount
booking_object.pay_back_by_sportclub = booking_object.final_price
booking_object.cancelled_by_sportclub = True
booking_object.cancelled_by_sportclub_at_date = today
booking_object.cancelled_by_sportclub_at_time = now_time
booking_object.save()
session.save()
api = KavenegarAPI(settings.KAVENEGAR_API_KEY)
phone_number = booking_object.booker.phone_number
message_text = '''
سامانه ورزش کن\nبه اطلاع شما میرساند سانس
روز {first}
ساعت {second}
توسط مجموعه ورزشی مربوطه لغو شد. جهت دریافت هزینه پرداخت شده به مجموعه ورزشی مراجعه کنید.
'''.format(
first=str(session.day),
second=str(session.time.hour) + ':' + str(session.time.minute),
)
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': phone_number,
'message': message_text
}
response = api.sms_send(params)
return HttpResponseRedirect(
reverse('booking:cancelsuccessbysportclub'))
except:
return HttpResponseRedirect(reverse('booking:cancellingerror'))
def send_sms(self, number):
try:
phone = Phone.objects.get(phone_number=number)
except Exception:
phone = Phone(phone_number=number)
phone.code = randint(10000, 99999)
phone.save()
try:
api = KavenegarAPI(
'526D6956397A6B786F30464C38724E302F5A67646E6156322F677A7037633573447349373955426C5473343D'
)
params = {
'receptor': str(phone.phone_number),
'message': str(phone.code),
}
response = api.sms_send(params)
print(response)
except Exception as e:
print(e)
def send_otp(phone, otp):
"""
sending OTP to the user phone for verifying by phone
"""
phone = [
phone,
]
try:
api = KavenegarAPI(Kavenegar_API)
params = {
'sender': '1000596446', # optional
'receptor': phone, # multiple mobile number, split by comma
'message': 'Your OTP is {}'.format(otp),
}
response = api.sms_send(params)
print('OTP: ', otp)
print(response)
except APIException as e:
print(e)
except HTTPException as e:
print(e)
def confirm_checkout(request):
# try:
user = request.user
customer = CustomerProfile.objects.get(user=user)
order = checkout_order(customer)
if customer.phone is not None:
api = KavenegarAPI(
'6652373751486A6D5A34584B476A466F346E616F7A313768553441726330554E')
params = {
'sender':
'1000596446',
'receptor':
customer.phone.raw_phone,
'message': ("کاربر گرامی، سفارش شما با کد " + order.order_id +
" با موفقیت ثبت گردید").encode('utf-8')
}
try:
response = api.sms_send(params)
except:
print("شماره کاربر وجود ندارد", customer.phone.raw_phone)
return Response(status=status.HTTP_200_OK)
def __init__(self) -> None:
self.api = KavenegarAPI(KAVENEGAR_KEY)
from kavenegar import KavenegarAPI, APIException, HTTPException
from wing import local_settings
api = KavenegarAPI(local_settings.kavenegar_api)
def verify(phone, password):
try:
params = {
'receptor': str(phone),
'token': password,
'template': 'verify'
}
response = api.verify_lookup(params)
return response
except APIException as e:
return e
except HTTPException as e:
return e
def lock_unlock(phone, lock, device_code):
if lock:
token = "lock"
else:
token = "unlock"
try:
params = {
'receptor': str(phone),
'token': token,
'token2': device_code,
def send(self, reciever, template):
sms = self.create(reciever=reciever, smsTemplate = template)
api = KavenegarAPI()
sms.response = api.sms_send()
def CommonUserSignupView(request):
api = KavenegarAPI(settings.KAVENEGAR_API_KEY)
try:
last_retry_str = request.session['last_retry']
retries = request.session['retries']
last_retry = datetime.datetime.strptime(last_retry_str,
"%Y-%m-%d %H:%M:%S")
except:
last_retry = datetime.datetime.now()
now = datetime.datetime.now()
if now >= last_retry or retries != 2:
if request.method == 'POST':
user_form = UserForm(data=request.POST)
commonuser_form = CommonUserForm(data=request.POST)
if user_form.is_valid() and commonuser_form.is_valid():
request.session['name'] = user_form.cleaned_data.get(
'first_name')
request.session['password1'] = user_form.cleaned_data.get(
'password1')
request.session['username'] = user_form.cleaned_data.get(
'username')
request.session['email'] = user_form.cleaned_data.get('email')
phone_number = '0' + user_form.cleaned_data.get('username')
#### generating code
var = '1234567890'
random_code = ''
for i in range(5):
c = random.choice(var)
random_code += c
code = random_code
######### send code to commonuser
params = {
'sender':
settings.KAVENEGAR_PHONE_NUMBER,
'receptor':
phone_number,
'message':
'سامانه ورزش کن \n' + 'کد فعالسازی شما' + ' :' + code
}
try:
response = api.sms_send(params)
request.session['code'] = code
request.session['phone_number'] = phone_number
now = datetime.datetime.now() + datetime.timedelta(
minutes=2)
str_now = str(now.year) + '-' + str(now.month) + '-' + str(
now.day) + ' ' + str(now.hour) + ':' + str(
now.minute) + ':' + str(now.second)
request.session['last_retry'] = str_now
try:
if request.session['retries'] == 1:
request.session['retries'] = 2
except:
request.session['retries'] = 1
except:
return HttpResponseRedirect(
reverse('accounts:wrongphonenumber'))
return HttpResponseRedirect(reverse('commonuser:confirmation'))
else:
print(user_form.errors, commonuser_form.errors)
else:
user_form = UserForm()
commonuser_form = CommonUserForm()
return render(request, 'commonuser/commonusersignup.html', {
'user_form': user_form,
'commonuser_form': commonuser_form
})
else:
return HttpResponseRedirect(reverse('commonuser:twominwait'))
from kavenegar import KavenegarAPI, APIException, HTTPException
api = KavenegarAPI('')
def verify(phone, password):
try:
params = {
'receptor': str(phone),
'token': password,
'template': 'verify'
}
response = api.verify_lookup(params)
return response
except APIException as e:
return e
except HTTPException as e:
return e
def send_sms(phone, message):
try:
params = {
'receptor': str(phone),
'message': message,
}
response = api.sms_send(params)
return response
except APIException as e:
return e
except HTTPException as e:
def ForgotPasswordView(request):
api = KavenegarAPI(settings.KAVENEGAR_API_KEY)
try:
last_retry_str = request.session['last_retry']
last_retry = datetime.datetime.strptime(last_retry_str,"%Y-%m-%d %H:%M:%S")
except:
last_retry = datetime.datetime.now()
now = datetime.datetime.now()
if now >= last_retry:
if request.method == 'POST':
data = request.POST.copy()
form = ForgotPasswordForm(data=request.POST)
phone_number_exists = False
if form.is_valid():
phone_number = form.cleaned_data.get('phone_number')
try :
commonuser = get_object_or_404(CommonUserModel,phone_number = phone_number)
if commonuser:
print(commonuser)
user = commonuser.user
var = 'abcdefghijklmnpqrstuvwxyzABCDEFIJKLMNPQRSTUVWXYZ123456789'
new_password=''
for i in range(0,random.randrange(10,13,1)):
c = random.choice(var)
new_password += c
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': phone_number,
'message' : 'سامانه ورزش کن\n' + str(user.username) + ' :'+'نام کاربری شما'+'\n'+ new_password +' :'+ 'رمز عبور جدید شما '
}
response = api.sms_send(params)
phone_number_exists = True
user.set_password(new_password)
print(user.password)
user.save()
now = datetime.datetime.now() + datetime.timedelta(minutes=3)
str_now = str(now.year)+'-'+str(now.month)+'-'+str(now.day)+' '+str(now.hour)+':'+str(now.minute)+':'+str(now.second)
request.session['last_retry'] = str_now
return HttpResponseRedirect(reverse('login'))
except:
pass
try :
sportclub = get_object_or_404(SportClubModel,phone_number = phone_number)
if sportclub:
user = sportclub.user
var = 'abcdefghijklmnpqrstuvwxyzABCDEFIJKLMNPQRSTUVWXYZ123456789'
new_password=''
for i in range(0,random.randrange(10,13,1)):
c = random.choice(var)
new_password += c
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': phone_number,
'message' : 'سامانه ورزش کن\n' + str(user.username) + ' :'+'نام کاربری شما'+'\n'+ new_password +' :'+ 'رمز عبور جدید شما '
}
response = api.sms_send(params)
phone_number_exists = True
user.set_password(new_password)
print(user.password)
user.save()
now = datetime.datetime.now() + datetime.timedelta(minutes=3)
str_now = str(now.year)+'-'+str(now.month)+'-'+str(now.day)+' '+str(now.hour)+':'+str(now.minute)+':'+str(now.second)
request.session['last_retry'] = str_now
return HttpResponseRedirect(reverse('login'))
except:
pass
try :
masteruser = get_object_or_404(MasterUserModel,phone_number = phone_number)
if masteruser:
user = masteruser.user
var = 'abcdefghijklmnpqrstuvwxyzABCDEFIJKLMNPQRSTUVWXYZ123456789'
new_password=''
for i in range(0,random.randrange(10,13,1)):
c = random.choice(var)
new_password += c
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': phone_number,
'message' : 'سامانه ورزش کن\n' + str(user.username) + ' :'+'نام کاربری شما'+'\n'+ new_password +' :'+ 'رمز عبور جدید شما '
}
print(user.password)
response = api.sms_send(params)
phone_number_exists = True
user.set_password(new_password)
user.save()
now = datetime.datetime.now() + datetime.timedelta(minutes=3)
str_now = str(now.year)+'-'+str(now.month)+'-'+str(now.day)+' '+str(now.hour)+':'+str(now.minute)+':'+str(now.second)
request.session['last_retry'] = str_now
return HttpResponseRedirect(reverse('login'))
except:
pass
else:
print(form.errors)
if not phone_number_exists:
return HttpResponseRedirect(reverse('accounts:wrongphonenumber'))
else:
form = ForgotPasswordForm()
return render(request,'accounts/forgotpassword.html',{'form':form})
else:
return HttpResponseRedirect(reverse('commonuser:twominwait'))
def CloudMessageView(request):
api = KavenegarAPI(settings.KAVENEGAR_API_KEY)
if request.user.is_superuser:
if request.method == 'POST':
types_form = TypesForm(data = request.POST )
message_form = MessageForm(data = request.POST)
if message_form.is_valid() and types_form.is_valid():
masterusers = types_form.cleaned_data['masterusers']
sportclubs = types_form.cleaned_data['sportclubs']
commonusers = types_form.cleaned_data['commonusers']
message_text = message_form.cleaned_data.get('text')
failed_to_users = ''' fails: \n '''
success = ''' success: \n '''
if masterusers:
master_users = MasterUserModel.objects.all()
for master_user in master_users:
try:
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': master_user.phone_number,
'message' : message_text
}
response = api.sms_send(params)
success += 'masteruser- name: ' +str(master_user.user.username) +' with phone_number: ' + str(master_user.phone_number) +'\n'
except:
failed_to_users += 'masteruser- name: ' +str(master_user.user.username) +' with phone_number: ' + str(master_user.phone_number) +'\n'
if sportclubs:
sport_clubs = SportClubModel.objects.all()
for sport_club in sport_clubs:
try:
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': sport_club.phone_number,
'message' : message_text
}
response = api.sms_send(params)
success += 'sportclub- username: '******' with phone_number: ' + str(sport_club.phone_number) +'\n'
except:
failed_to_users += 'sportclub- username: '******' with phone_number: ' + str(sport_club.phone_number) +'\n'
if commonusers:
common_users = CommonUserModel.objects.all()
for common_user in common_users:
try:
params = {
'sender': settings.KAVENEGAR_PHONE_NUMBER,
'receptor': common_user.phone_number,
'message' : message_text
}
response = api.sms_send(params)
success += 'commonuser- username: '******' with phone_number: ' + str(common_user.phone_number) +'\n'
except:
failed_to_users += 'commonuser- username: '******' with phone_number: ' + str(common_user.phone_number) +'\n'
superuser_instance = get_object_or_404(UserModel, slug = request.user.slug)
superuser_instance_logs = superuser_instance.user_logs
to = ''
if commonusers:
to += 'Common Users '
if sportclubs:
to += 'Sport Clubs '
if masterusers:
to += 'Master Users '
now = jdatetime.datetime.now()
dtime = str(now.year)+'-'+str(now.month)+'-'+ str(now.day)+' '+str(now.hour)+':'+str(now.minute)+':'+str(now.second)
new_log = '''{previous_logs}\n
On {date_time} \n
Sent Cloud Message To: {to}\n
Message:\n
{message}
-------------------------------------------------------
'''.format(previous_logs = superuser_instance_logs,
date_time = dtime,
to = to,
message = str(message_text),)
superuser_instance.user_logs = new_log
superuser_instance.save()
return render(request,'accounts/cloudmessage.html',
{'failed_to_users':failed_to_users,
'success':success})
else:
message_form = MessageForm()
types_form = TypesForm()
return render(request,'accounts/cloudmessage.html',
{'message_form':message_form,
'types_form':types_form})
def CloudMessageView(request):
api = KavenegarAPI(
'30383967456C38706753473546583443536233774E374E6E702B5832386C7648')
if request.user.is_superuser:
if request.method == 'POST':
types_form = TypesForm(data=request.POST)
message_form = MessageForm(data=request.POST)
if message_form.is_valid() and types_form.is_valid():
masterusers = types_form.cleaned_data['masterusers']
sportclubs = types_form.cleaned_data['sportclubs']
commonusers = types_form.cleaned_data['commonusers']
message_text = message_form.cleaned_data.get('text')
if masterusers:
master_users = MasterUserModel.objects.all()
for master_user in master_users:
params = {
'sender': '100065995',
'receptor': master_user.phone_number,
'message': message_text
}
response = api.sms_send(params)
if sportclubs:
sport_clubs = SportClubModel.objects.all()
for sport_club in sport_clubs:
params = {
'sender': '100065995',
'receptor': sport_club.phone_number,
'message': message_text
}
response = api.sms_send(params)
if commonusers:
common_users = CommonUserModel.objects.all()
for common_user in common_users:
params = {
'sender': '100065995',
'receptor': common_user.phone_number,
'message': message_text
}
response = api.sms_send(params)
superuser_instance = get_object_or_404(UserModel,
slug=request.user.slug)
superuser_instance_logs = superuser_instance.user_logs
to = ''
if commonusers:
to += 'Common Users '
if sportclubs:
to += 'Sport Clubs '
if masterusers:
to += 'Master Users '
new_log = '''{previous_logs}\n
On {date_time}:\n
Sent Cloud Message To: {to}\n
Message:\n
{message}
-------------------------------------------------------
'''.format(
previous_logs=superuser_instance_logs,
date_time=timezone.localtime(timezone.now()),
to=to,
message=str(message_text),
)
superuser_instance.user_logs = new_log
superuser_instance.save()
return HttpResponseRedirect(
reverse('accounts:profile',
kwargs={'slug': request.user.slug}))
else:
message_form = MessageForm()
types_form = TypesForm()
return render(request, 'accounts/cloudmessage.html', {
'message_form': message_form,
'types_form': types_form
})
class Kavenegar(SMS):
def __init__(self) -> None:
self.api = KavenegarAPI(KAVENEGAR_KEY)
def _send(self, mobile_number, **kwargs):
kwargs['receptor'] = mobile_number
return self._verify_send(**kwargs)
def _sms_send(self, **kwargs):
try:
response = self.api.sms_send(kwargs)
return response
except APIException as e:
return e
except HTTPException as e:
return e
def _verify_send(self, **kwargs):
try:
response = self.api.verify_lookup(kwargs)
return response
except APIException as e:
return e
except HTTPException as e:
return e
def _log(self, res, ip):
if isinstance(res, Exception):
return logger.error(res)
if isinstance(res, list):
res = res[0]
app_timezone = timezone.get_default_timezone()
return SMSModel.objects.create(
cost=res['cost'],
datetime=datetime.fromtimestamp(
res['date']).astimezone(app_timezone),
receptor=res['receptor'],
sender=res['sender'],
statustext=res['statustext'],
status=res['status'],
message=res['message'],
messageid=res['messageid'],
user_ip=ip,
)
def generate_code(self, mobile_number):
yesterday = make_aware(datetime.today() - timedelta(days=1))
user_phone_valid = UserphoneValid.objects.filter(
MobileNumber=mobile_number, Date__gte=yesterday, Validation=False)
if user_phone_valid.exists():
return user_phone_valid[0].ValidCode
else:
return str(random.randint(100000, 999999))
def _get_try_count(self, mobile_number, ip, deltatime):
return SMSModel.objects.filter(
(Q(receptor=mobile_number) | Q(user_ip=ip)),
datetime__gte=deltatime).count()
def _confirm_allowed(self, mobile_number, ip):
'''
this method check this user is allowed to receive SMS
now the only policy is checking maximux allowed number of sms
return :
confirm -> True
not confirm -> False
'''
MAX_NUMBER_SMS_IN_10_MIN = 5
MAX_NUMBER_SMS_IN_A_DAY = 10
# check that user is not overloading SMS with many requests
ten_minutes_ago = timezone.now() + timedelta(minutes=-10)
one_day_ago = timezone.now() + timedelta(hours=-24)
count_10min = self._get_try_count(mobile_number, ip, ten_minutes_ago)
count_day = self._get_try_count(mobile_number, ip, one_day_ago)
if count_day < MAX_NUMBER_SMS_IN_A_DAY:
if count_10min < MAX_NUMBER_SMS_IN_10_MIN:
return None
else:
return 'شما بیشتر از تعداد مجاز درخواست کردید. لطفا 10 دقیقه دیگر امتحان کنید.'
else:
return 'شما بیشتر از تعداد مجاز درخواست کردید. لطفا فردا دوباره امتحان کنید.'
def CommonUserSignupView(request):
api = KavenegarAPI(
'30383967456C38706753473546583443536233774E374E6E702B5832386C7648')
try:
last_retry_str = request.session['last_retry']
last_retry = datetime.datetime.strptime(last_retry_str,
"%Y-%m-%d %H:%M:%S")
except:
last_retry = datetime.datetime.now()
now = datetime.datetime.now()
if now >= last_retry:
if request.method == 'POST':
user_form = UserForm(data=request.POST)
commonuser_form = CommonUserForm(data=request.POST)
if user_form.is_valid() and commonuser_form.is_valid():
phone_number = commonuser_form.cleaned_data.get('phone_number')
user = user_form.save(commit=False)
user.is_commonuser = True
user.is_active = False
user.save()
request.session['user_slug'] = user.slug
commonuser = commonuser_form.save(commit=False)
commonuser.user = user
if 'picture' in request.FILES:
commonuser.picture = request.FILES['picture']
commonuser.save()
#### generating code
var = '1234567890'
random_code = ''
for i in range(5):
c = random.choice(var)
random_code += c
######
code = random_code
######### send code to commonuser
params = {
'sender':
'10008000300010',
'receptor':
phone_number,
'message':
'سامانه ورزش کن \n' + 'کد فعالسازی شما' + ' :' + code
}
try:
response = api.sms_send(params)
request.session['code'] = code
request.session['phone_number'] = phone_number
now = datetime.datetime.now() + datetime.timedelta(
minutes=1)
str_now = str(now.year) + '-' + str(now.month) + '-' + str(
now.day) + ' ' + str(now.hour) + ':' + str(
now.minute) + ':' + str(now.second)
request.session['last_retry'] = str_now
#################################
except:
return HttpResponseRedirect(
reverse('accounts:wrongphonenumber'))
return HttpResponseRedirect(reverse('commonuser:confirmation'))
else:
# One of the forms was invalid if this else gets called.
#redirect to another page or anything else
print(user_form.errors, commonuser_form.errors)
else:
user_form = UserForm()
commonuser_form = CommonUserForm()
return render(request, 'commonuser/commonusersignup.html', {
'user_form': user_form,
'commonuser_form': commonuser_form
})
else:
return HttpResponseRedirect(reverse('commonuser:twominwait'))
