def post(self):
self.check_CSRF()
product = xstr(self.request.get('product'))
quantity = xint(self.request.get('quantity'))
order_type = xstr(self.request.get('order_type'))
purchaser_email = xstr(self.request.get('purchaser_email'))
purchaser_email = purchaser_email if purchaser_email else None
purchaser_user_id = xint(self.request.get('purchaser_user_id'))
purchaser_user_id = purchaser_user_id if purchaser_user_id != 0 else None
info = xstr(self.request.get('info'))
info = info if info else None
order_id = webapp2_extras.security.generate_random_string(
length=10, pool=webapp2_extras.security.DIGITS)
licence_keys = EnkiModelProductKey.generate_licence_keys(quantity)
licence_keys = licence_keys.replace('-', '').split()
for licence_key in licence_keys:
item = EnkiModelProductKey(licence_key=licence_key,
order_id=order_id,
product_name=product,
shop_name='Generator',
quantity=quantity,
order_type=order_type,
purchaser_email=purchaser_email,
purchaser_user_id=purchaser_user_id,
info=info)
item.put()
licence_key_display = []
for item in licence_keys:
item_dash = EnkiModelProductKey.insert_dashes_5_10(item)
licence_key_display.append(item_dash)
self.add_infomessage(
MSG.INFORMATION(), '<h3>Licence keys generated</h3>' + '<ul>' +
'<li>product_name = <em>' + product + '</em></li>' +
'<li>order_type = <em>' + order_type + '</em></li>' +
'<li>order_id = <em>' + order_id + '</em></li>' +
'<li>quantity = <em>' + xstr(quantity) + '</em></li>' +
'<li>Recipient mail (purchaser_email) = <em>' +
(purchaser_email if purchaser_email else 'none') + '</em></li>' +
'<li>Recipient user id (purchaser_user_id) = <em>' +
(xstr(purchaser_user_id) if purchaser_user_id else 'none') +
'</em></li>' + '<li>info = <em>' + (info if info else 'none') +
'</em></li>' + '<li>licence_key(s) = <br><em>' +
'<br>'.join(licence_key_display) + '</em></li>' + '</ul>')
self.redirect('licencesgeneratefree')
def post(self):
secret = xstr(self.request.get('secret'))
if secret == settings.SECRET_FASTSPRING or enki.libutil.is_debug(
) or settings.ENKI_EMULATE_STORE:
quantity = xint(self.request.get('quantity'))
licence_keys = EnkiModelProductKey.generate_licence_keys(quantity)
self.response.write(licence_keys)
return
self.abort(404)
def post(self):
secret = xstr(self.request.get('secret'))
if secret == settings.SECRET_FASTSPRING or enki.libutil.is_debug(
) or settings.ENKI_EMULATE_STORE:
licence_key_bundle = xstr(self.request.get('licence_key'))
purchase_price = xstr(self.request.get('purchase_price'))
order_id = xstr(self.request.get('order_id'))
product_name = xstr(self.request.get('product_name'))
purchaser_email = xstr(self.request.get('purchaser_email'))
shop_name = xstr(self.request.get('shop_name'))
quantity = xint(self.request.get('quantity'))
if secret == settings.SECRET_FASTSPRING:
is_test = self.request.get('is_test')
if is_test.capitalize() == 'True':
order_type = 'test'
else:
order_type = 'purchase'
else:
order_type = xstr(self.request.get('order_type'))
purchaser_user_id = None
token_purchasebyuser = xstr(self.request.get('referrer'))
if token_purchasebyuser:
token = EnkiModelTokenVerify.get_by_token_type(
token_purchasebyuser, 'purchasebyuser')
if token:
purchaser_user_id = token.user_id
token.key.delete()
licence_keys = licence_key_bundle.replace('-', '').split()
for licence_key in licence_keys:
item = EnkiModelProductKey(licence_key=licence_key,
purchase_price=purchase_price,
order_id=order_id,
product_name=product_name,
purchaser_email=purchaser_email,
shop_name=shop_name,
quantity=quantity,
purchaser_user_id=purchaser_user_id,
order_type=order_type)
item.put()
return
def post( self, forum ):
if self.ensure_is_logged_in() and self.ensure_has_display_name():
if forum.isdigit() and EnkiModelForum.get_by_id( int( forum )):
user_id = self.user_id
thread_title = self.request.get( 'thread_title' )
post_body = self.request.get( 'post_body' )
thread_sticky_order = xint( self.request.get( 'sticky_order_thread' ))
post_sticky_order = xint( self.request.get( 'sticky_order_post' ))
submit_type = self.request.get( 'submittype' )
error_message_threadtitle = ''
error_message_postbody = ''
pmtoken = self.request.get( 'preventmultitoken' )
show_input = True
if submit_type == 'cancel' or submit_type == 'input':
thread_title = ''
post_body = ''
thread_sticky_order = 0
post_sticky_order = 0
if submit_type == 'input':
pmtoken = EnkiModelTokenVerify.add_preventmultipost_token( 'preventmultipost' )
else:
self.check_CSRF()
if not thread_title:
error_message_threadtitle = MSG.THREAD_TITLE_NEEDED( )
else:
exceed = len( thread_title ) - EnkiModelThread.THREAD_TITLE_LENGTH_MAX
if exceed > 0:
error_message_threadtitle = MSG.THREAD_TITLE_TOO_LONG( exceed )
if not post_body:
error_message_postbody = MSG.POST_BODY_NEEDED()
else:
exceed = len( post_body ) - EnkiModelPost.POST_LENGTH_MAX
if exceed > 0:
error_message_postbody = MSG.POST_BODY_TOO_LONG( exceed )
if not error_message_threadtitle and not error_message_postbody:
if submit_type == 'submit':
if EnkiModelTokenVerify.check_and_delete_preventmultipost_token( pmtoken, 'preventmultipost' ):
result = EnkiModelPost.add_thread_and_post( user_id, forum, thread_title, thread_sticky_order, post_body, post_sticky_order )
if result == enki.libutil.ENKILIB_OK:
self.add_infomessage( MSG.SUCCESS( ), MSG.THREAD_PUBLISHED())
url = enki.libutil.get_local_url( 'forum', { 'forum':forum })
self.send_email_admin( 'FTPA', url )
self.redirect( url )
return
else:
error_threadtitle = MSG.FAIL_THREAD_SUBMISSION()
else:
thread_title = ''
post_body = ''
self.render_tmpl( 'forum.html', CSRFneeded = show_input,
active_menu = 'forums',
data = EnkiModelThread.get_forum_data( forum ),
has_permission_sticky = self.has_permissions( self.enki_user, [ 'PFPS', 'PFTS' ]),
show_input = show_input,
preventmultitoken = pmtoken,
error_threadtitle = error_message_threadtitle,
error_postbody = error_message_postbody,
maxpostlength = EnkiModelPost.POST_LENGTH_MAX,
maxthreadtitlelength = EnkiModelThread.THREAD_TITLE_LENGTH_MAX,
threadtitle = thread_title,
postbody = post_body,
threadstickyorder = thread_sticky_order,
poststickyorder = post_sticky_order,
preview = True if ( submit_type == 'preview' and thread_title and post_body ) else False)
def post( self, post ):
if self.ensure_is_logged_in() and self.ensure_has_display_name():
if post.isdigit() and EnkiModelPost.get_by_id( int( post )):
data = EnkiModelPost.get_post_data( post )
is_author = True if self.user_id == data.author_data.user_id else False
user = self.user_id
post_body = self.request.get( 'post_body' )
submit_type = self.request.get( 'submittype' )
change = self.request.get( 'change' )
error_message = ''
preview = ''
if submit_type == 'delete':
self.check_CSRF()
result = EnkiModelPost.delete_post( user, post )
if result[ 0 ] == enki.libutil.ENKILIB_OK:
self.add_infomessage( MSG.SUCCESS( ), MSG.POST_DELETED())
url = enki.libutil.get_local_url( 'thread', { 'thread' : result[ 1 ]})
self.send_email_admin( 'FPD', url )
self.redirect( url ) # redirect to parent thread
return
else:
error_message = MSG.FAIL_POST_DELETION()
elif submit_type == 'cancel':
self.redirect( data.post_page )
return
else:
if not post_body:
error_message = MSG.POST_BODY_NEEDED()
else:
exceed = len( post_body ) - EnkiModelPost.POST_LENGTH_MAX
if exceed > 0:
error_message = MSG.POST_BODY_TOO_LONG( exceed )
if not error_message:
post_sticky_order = xint( self.request.get( 'sticky_order' ))
if submit_type == 'submit':
self.check_CSRF()
result = EnkiModelPost.edit_post( user, post, post_body, post_sticky_order )
if result[ 0 ] == enki.libutil.ENKILIB_OK:
self.add_infomessage( MSG.SUCCESS( ), MSG.POST_MODIFIED())
url = enki.libutil.get_local_url( 'thread', { 'thread' : result[ 1 ]})
self.send_email_admin( 'FPE', url )
self.redirect( url ) # redirect to parent thread
return
else:
error_message = MSG.FAIL_POST_MODIFICATION()
elif submit_type == 'preview':
preview = post_body
self.render_tmpl( 'post.html',
active_menu = 'forums',
data = data,
change = change,
isauthor = is_author,
has_permission_sticky = self.has_permissions( self.enki_user, [ 'PFPS' ]),
error = error_message,
postbody = post_body,
maxpostlength = EnkiModelPost.POST_LENGTH_MAX,
preview = preview )
def post( self, thread ):
if self.ensure_is_logged_in() and self.ensure_has_display_name():
if thread.isdigit() and EnkiModelThread.get_by_id( int( thread )):
user = self.user_id
post_body = self.request.get( 'post_body' )
submit_type = self.request.get( 'submittype' )
post_count = str( self.request.get( 'count' ))
post_requested = str( self.request.get( 'start' ))
if not post_count:
post_count = EnkiModelPost.POSTS_PER_PAGE
if not post_requested:
post_requested = EnkiModelPost.get_first_post_on_page( EnkiModelPost.get_page( EnkiModelThread.get_by_id( int( thread )), EnkiModelPost.POST_LAST, int( post_count )), int( post_count ))
error_message = ''
preview = ''
pmtoken = self.request.get( 'preventmultitoken' )
show_input = True
if submit_type == 'input':
post_body = ''
pmtoken = EnkiModelTokenVerify.add_preventmultipost_token( 'preventmultipost' )
else:
self.check_CSRF()
if submit_type != 'cancel':
if not post_body:
error_message = MSG.POST_BODY_NEEDED()
else:
exceed = len( post_body ) - EnkiModelPost.POST_LENGTH_MAX
if exceed > 0:
error_message = MSG.POST_BODY_TOO_LONG( exceed )
if not error_message:
post_sticky_order = xint( self.request.get( 'sticky_order' ))
if submit_type == 'submit':
if EnkiModelTokenVerify.check_and_delete_preventmultipost_token( pmtoken, 'preventmultipost' ):
result = EnkiModelPost.add_post( user, thread, post_body, post_sticky_order )
if result == enki.libutil.ENKILIB_OK:
self.add_infomessage( MSG.SUCCESS( ), MSG.POST_PUBLISHED())
post_requested = EnkiModelPost.get_first_post_on_page( EnkiModelPost.get_page( EnkiModelThread.get_by_id( int( thread )), EnkiModelPost.POST_LAST, int( post_count )), int( post_count ))
url = enki.libutil.get_local_url( 'thread', { 'thread': thread, 'start': str( post_requested ), 'count': str( post_count )})
self.send_email_admin( 'FPA', url )
self.redirect( url )
return
else:
error_message = MSG.FAIL_POST_SUBMISSION()
else:
post_body = ''
elif submit_type == 'preview':
preview = post_body
elif submit_type == 'cancel':
post_body = ''
data = EnkiModelPost.get_thread_data( thread, post_requested, post_count )
pagination = EnkiModelPost.get_thread_pagination_data( thread, post_requested, post_count )
self.render_tmpl( 'thread.html', CSRFneeded = show_input,
active_menu = 'forums',
data = data,
pagination = pagination,
user_id = self.user_id,
has_permission_sticky = self.has_permissions( self.enki_user, [ 'PFPS' ]),
show_input = show_input,
preventmultitoken = pmtoken,
error = error_message,
maxpostlength = EnkiModelPost.POST_LENGTH_MAX,
postbody = post_body,
preview = preview )
def post(self):
if not settings.SECRET_FASTSPRING or enki.libutil.is_debug(
) or settings.ENKI_EMULATE_STORE:
self.check_CSRF()
product = xstr(self.request.get('product'))
quantity = xint(self.request.get('quantity'))
purchase_price = xstr(self.request.get('purchase_price'))
purchaser_email = xstr(self.request.get('purchaser_email'))
order_type = xstr(self.request.get('order_type'))
licence_keys = 'not generated'
user_id = ''
order_id = webapp2_extras.security.generate_random_string(
length=10, pool=webapp2_extras.security.DIGITS)
url = webapp2.uri_for('generatelicencefastspring', _full=True)
form_fields = {
'secret': 'pretendsecret',
'quantity': str(quantity)
}
form_data = enki.libutil.urlencode(form_fields)
result = urlfetch.fetch(url=url,
payload=form_data,
method=urlfetch.POST)
if result.status_code == 200:
licence_keys = result.content.replace('-', '')
referrer = xstr(self.request.get('referrer'))
token = EnkiModelTokenVerify.get_by_token_type(
referrer, 'purchasebyuser')
if token:
user_id = token.user_id
licence_key_display = []
for item in licence_keys.split():
item_dash = EnkiModelProductKey.insert_dashes_5_10(item)
licence_key_display.append(item_dash)
self.add_infomessage(
MSG.INFORMATION(),
'<h3>FastSpring Store Emulator - Step 1</h3>' +
'<h4>Emulated purchase details</h4>' + '<ul>' +
'<li><EnkiModelProductKey> #{FastSpring variable} = <em><emulated value></em></li>'
+ '<li>product_name #{orderItem.productName} = <em>' +
product + '</em></li>' + '<li>order_id #{order.id} = <em>' +
order_id + '</em></li>' +
'<li>quantity #{orderItem.quantity} = <em>' + xstr(quantity) +
'</em></li>' +
'<li>purchase_price #{orderItem.totalUSD} = <em>' +
purchase_price + '</em></li>' +
'<li>purchaser_email #{order.customer.email} = <em>' +
purchaser_email + '</em></li>' +
'<li>licence_key #{orderItem.fulfillment.licence.licences.list} = <br><em><b>'
+ '<br>'.join(licence_key_display) + '</b></em></li>' +
'<li>shop_name = <em>Emulator</em></li>' +
'<li>order_type = <em>' + order_type + '</em></li>' + '</ul>'
'<h4>Internal data - generated if the purchaser was logged in when they bought the product</h4>'
+ '<ul>' +
'<li>EnkiModelTokenVerify.user_id = purchaser user_id = <em>' +
(xstr(user_id) if user_id else 'None') + '</em></li>' +
'<li>EnkiModelTokenVerify.type purchasebyuser referrer #{order.referrer} = <em>'
+ (xstr(referrer) if referrer else 'None') + '</em></li>' +
'</ul>')
url = webapp2.uri_for('ordercompletefastspring', _full=True)
form_fields = {
'licence_key': licence_keys,
'purchase_price': purchase_price,
'order_id': order_id,
'order_type': order_type,
'product_name': product,
'purchaser_email': purchaser_email,
'shop_name': 'Emulator',
'quantity': quantity,
'referrer': referrer,
'is_test': 'true'
}
form_data = enki.libutil.urlencode(form_fields)
result = urlfetch.fetch(url=url,
payload=form_data,
method=urlfetch.POST)
if result.status_code == 200:
message_view_library = ''
if self.is_logged_in():
message_view_library = '<p><a href="/profile" class="alert-link">View and activate licence keys</a>.</p>'
self.add_infomessage(
MSG.INFORMATION(),
'<h3>FastSpring Store Emulator - Step 2</h3><p>Purchase records created<p>'
+ message_view_library)
else:
self.add_infomessage(
MSG.WARNING(),
'<h3>FastSpring Store Emulator - Step 2 FAILED: Purchase records not created</h3>'
)
self.redirect_to_relevant_page()