def sms(request):
"""
Handles both the GET and the POST
first thing is checks to make sure that the incoming message
has the right secret device key
POST:
use the post data to create a SMS, and add it to the database
will return empty 200 if success, or 500/400 with an {'error': <error message>} json body
GET:
gets up to max_sms sms, and returns them in a json list
as well as a sms_count
"""
attrs = ('to_number','from_number','body')
if request.method == "POST":
"""
Handles an incoming SMS
"""
device = authorize(request.POST.get('key'))
if device is None:
return HttpResponseForbidden(str(device))
sms_dict = {}
for attr in attrs:
post_val = request.POST.get(attr)
if post_val is None:
return HttpResponseBadRequest("POST must have attribute %s" % attr)
sms_dict[attr] = post_val
new_sms = SMS(**sms_dict)
sms_handlers = []
sms_handler_tuple = getattr(settings,'SMS_HANDLERS',[])
for sms_handler_string in sms_handler_tuple:
sms_handlers.append(get_callable(sms_handler_string))
# call the handlers? is this the best way?
for sms_handler in sms_handlers:
retval = sms_handler(new_sms)
if retval is False:
break
return HttpResponse()
elif request.method == "GET":
"""
Remove this section if you will not be using
The database as a queue for SMS sending-consumers
"""
device = authorize(request.GET.get('key'))
if device is None:
return HttpResponseForbidden(str(device))
try:
return dj_simple_sms.SMS_SENDER.respond_to_get(request)
except NotImplementedError:
return HttpResponseNotAllowed('GET')
count_exceptions = 0
for log in reddit.subreddit(SUBREDDIT).mod.log(limit=10000000):
if count_exceptions > 10:
print('too many exceptions, terminating')
return
mod = log.mod
if mod.name == 'AutoModerator':
continue
action_created = dt.datetime.fromtimestamp(log.created_utc)
action = log.action
if action in COMMENT_ACTIONS:
cid = log.target_fullname.split('_')[-1]
try:
persist_comment(reddit, log, cid)
except Exception as e:
count_exceptions += 1
print('mod action already in db')
print(e)
elif action in LINK_ACTIONS:
try:
lid = log.target_fullname.split('_')[-1]
persist_link(reddit, log, lid)
except Exception as e:
print('mod action already in db')
print(e)
if __name__ == "__main__":
reddit_all = authorize()
persist_modlog(reddit_all)
def sms(request):
"""
Handles both the get and the post
first thing is checks to make sure that the incoming message
has the right secret device key
POST:
use the post data to create a SMS, and add it to the database
will return empty 200 if success, or 500/400 with an {'error': <error message>} json body
GET:
gets up to max_sms sms, and returns them in a json list
as well as a sms_count
"""
attrs = ('to_number','from_number','body')
if request.method == "POST":
device = authorize(request.POST.get('key'))
if device is None:
return HttpResponseForbidden()
sms_dict = {}
for attr in attrs:
post_val = request.POST.get(attr)
if post_val is None:
return HttpResponseBadRequest("POST must have attribute %s" % attr)
sms_dict[attr] = post_val
new_sms = SMS(**sms_dict)
sms_handlers = []
sms_handler_tuple = getattr(settings,'SMS_HANDLERS',[])
for sms_handler_string in sms_handler_tuple:
sms_handlers.append(get_callable(sms_handler_string))
# call the handlers? is this the best way?
for sms_handler in sms_handlers:
retval = sms_handler(new_sms)
if retval is False:
break
return HttpResponse()
elif request.method == "GET":
"""
Remove this section if you will not be using
The database as a queue for SMS sending-consumers
"""
device = authorize(request.GET.get('key'))
if device is None:
return HttpResponseForbidden()
max_sms = request.GET.get('max_sms',getattr(settings,'SMS_MAX_SMS_GET',10))
# ok, get that many!
if max_sms is None:
sms_set = SMS.objects.all().order_by('datetime')
else:
sms_set = SMS.objects.all().order_by('datetime')[:max_sms]
sms_list = list(sms_set.values(*attrs))
count = len(sms_list)
data_out = {'sms_count':count,'sms':sms_list}
for sms in sms_set:
sms.delete()
return HttpResponse(json.dumps(data_out))
'body': comment.body,
'edited': comment.edited,
'ups': comment.ups,
'reports': reports,
'author': auth_name,
'removal_reason': comment.removal_reason,
'comment_obj': comment
}
comment_removal_idx[cid]['mod_actions'].append(
{log.mod.name: (action, action_created)})
return comment_removal_idx
def get_comment_user_report_stats(reddit):
comment_actions = get_comment_actions(reddit)
reason_counts_by_comment = {}
for cid, action_meta in comment_actions.items():
for r in action_meta['reports']:
print(r)
reason = r[0]
if reason not in reason_counts_by_comment:
reason_counts_by_comment[reason] = 0
reason_counts_by_comment[reason] += 1
print(reason_counts_by_comment)
if __name__ == "__main__":
reddit = authorize()
get_comment_user_report_stats(reddit)
def sms(request):
"""
Handles both the get and the post
first thing is checks to make sure that the incoming message
has the right secret device key
POST:
use the post data to create a SMS, and add it to the database
will return empty 200 if success, or 500/400 with an {'error': <error message>} json body
GET:
gets up to max_sms sms, and returns them in a json list
as well as a sms_count
"""
attrs = ('to_number', 'from_number', 'body')
if request.method == "POST":
device = authorize(request.POST.get('key'))
if device is None:
return HttpResponseForbidden()
sms_dict = {}
for attr in attrs:
post_val = request.POST.get(attr)
if post_val is None:
return HttpResponseBadRequest("POST must have attribute %s" %
attr)
sms_dict[attr] = post_val
new_sms = SMS(**sms_dict)
sms_handlers = []
sms_handler_tuple = getattr(settings, 'SMS_HANDLERS', [])
for sms_handler_string in sms_handler_tuple:
sms_handlers.append(get_callable(sms_handler_string))
# call the handlers? is this the best way?
for sms_handler in sms_handlers:
retval = sms_handler(new_sms)
if retval is False:
break
return HttpResponse()
elif request.method == "GET":
"""
Remove this section if you will not be using
The database as a queue for SMS sending-consumers
"""
device = authorize(request.GET.get('key'))
if device is None:
return HttpResponseForbidden()
max_sms = request.GET.get('max_sms',
getattr(settings, 'SMS_MAX_SMS_GET', 10))
# ok, get that many!
if max_sms is None:
sms_set = SMS.objects.all().order_by('datetime')
else:
sms_set = SMS.objects.all().order_by('datetime')[:max_sms]
sms_list = list(sms_set.values(*attrs))
count = len(sms_list)
data_out = {'sms_count': count, 'sms': sms_list}
for sms in sms_set:
sms.delete()
return HttpResponse(json.dumps(data_out))
def oauth_autorization(request):
http_auth = util.authorize(request.GET['code'])
request.session['credentials'] = http_auth.to_json()
return HttpResponseRedirect(reverse('auth:home'))
def sms(request):
"""
Handles both the GET and the POST
first thing is checks to make sure that the incoming message
has the right secret device key
POST:
use the post data to create a SMS, and add it to the database
will return empty 200 if success, or 500/400 with an {'error': <error message>} json body
GET:
gets up to max_sms sms, and returns them in a json list
as well as a sms_count
"""
attrs = ('to_number', 'from_number', 'body')
if request.method == "POST":
"""
Handles an incoming SMS
"""
device = authorize(request.POST.get('key'))
if device is None:
return HttpResponseForbidden(str(device))
sms_dict = {}
for attr in attrs:
post_val = request.POST.get(attr)
if post_val is None:
return HttpResponseBadRequest("POST must have attribute %s" %
attr)
sms_dict[attr] = post_val
new_sms = SMS(**sms_dict)
sms_handlers = []
sms_handler_tuple = getattr(settings, 'SMS_HANDLERS', [])
for sms_handler_string in sms_handler_tuple:
sms_handlers.append(get_callable(sms_handler_string))
# call the handlers? is this the best way?
for sms_handler in sms_handlers:
retval = sms_handler(new_sms)
if retval is False:
break
return HttpResponse()
elif request.method == "GET":
"""
Remove this section if you will not be using
The database as a queue for SMS sending-consumers
"""
device = authorize(request.GET.get('key'))
if device is None:
return HttpResponseForbidden(str(device))
try:
return dj_simple_sms.SMS_SENDER.respond_to_get(request)
except NotImplementedError:
return HttpResponseNotAllowed('GET')