def home(request): group_query = db.Query(Group) groups = group_query.fetch(20) if len(groups) <1: return redirect("/group/edit/") return respond('group_home.html', {'groups': groups,})
def edit(request): """Create or edit a listings. GET shows a blank form, POST processes it.""" user = users.GetCurrentUser() if user is None: return http.HttpResponseForbidden('You must be signed in to edit your allocations') query = Allocation.all() query.filter('creator =', user) result = query.fetch(limit=1) allocation = None flash = {} for entry in result: allocation = entry form = AllocationForm(data=request.POST or None, instance=allocation) if not request.POST: return common.respond(request, user, 'allocation', {'form': form, 'allocation': allocation, 'budget':TOTAL_BUDGET, 'flash': flash}) errors = form.errors if not errors: try: allocation = form.save(commit=False) except ValueError, err: errors['__all__'] = unicode(err)
def list(request, listing_id): user = users.GetCurrentUser() if user is None: return http.HttpResponseForbidden('You must be signed in to view listing values') listing_values = None listing = None lvs_paginator = None if request.GET.has_key('page'): page = int(request.GET['page']) else: page = 0 if listing_id: listing = get_listing(listing_id) lvs = ListingValue.all().order('-date').filter('listing_key = ', str(listing.key())) lvs_paginator = ObjectPaginator(lvs, 10) listing_values = lvs_paginator.get_page(page) if listing is None or listing_values is None or listing_id is None: return http.HttpResponseNotFound( 'No values exists for that listing (%r)' % listing_id) paginator = {} paginator['has_previous_page'] = lvs_paginator.has_previous_page(page) paginator['has_next_page'] = lvs_paginator.has_next_page(page) paginator['next_page_number'] = page+1 paginator['previous_page_number'] = page-1 return common.respond(request, user, 'values_list', {'listing': listing, 'listing_values' : listing_values, 'paginator': paginator})
def page_redirect(request, url): params = {} for code in ('login', 'power', 'param', 'missing'): if request.GET.has_key(code): params.update({"code_%s" % code: True,}) params.update({'url': "/%s" % url,}) return respond('redirect.html', params)
def get_key(request): symbol = None if request.GET.has_key('symbol'): symbol = request.GET['symbol'] else: return http.HttpResponseNotFound('Please provide symbol parameter') listing_key = get_key_from_symbol(symbol) if listing_key is None: return http.HttpResponseNotFound('None') return common.respond(request, None, 'key', {'listing_key': listing_key})
def edit(request, group_id): param = {} if group_id: group = get_group(group_id) require = check_user(group) if require: return redirect("/redirect/?%s" % require) users = get_users(group) param.update({'group': group, 'users': users,}) errs = get_param(request, 'errs') if errs: errs = errs.split(',') for err in errs: param.update({"%s_error" % err: True,}) return respond('group_edit.html', param)
def detail(request, group_id): group = get_group(group_id) if not group: raise Http404() require_privilege = check_user(group) summaries = [] +group.summaries summaries.sort() due_payer_index = group.summaries.index(summaries[0]) due_payer = get_user(group.members[due_payer_index]) params = {'fees': get_fees(group), 'members': get_users(group), 'is_valid_user': not require_privilege, 'group': group, 'due_payer': due_payer.name, 'due_amount': -summaries[0], } return respond('group_detail.html', params)
def delete(request): user = users.GetCurrentUser() if user is None: return http.HttpResponseForbidden('You must be signed in to delete listing values') symbol = None if request.GET.has_key('symbol'): symbol = request.GET['symbol'] else: return http.HttpResponseNotFound('Please provide symbol parameter') listing_key = listings.get_key_from_symbol(symbol) if listing_key is None: return http.HttpResponseNotFound('None') q = db.GqlQuery("SELECT * FROM ListingValue WHERE listing_key = :key", key = str(listing_key)) results = q.fetch(1000) while results: db.delete(results) results = q.fetch(1000, len(results)) return common.respond(request, user, 'values_delete')
def delete(request, fee_id): try: fee = get_fee(fee_id) group_id = fee.group.key().id() if not request.GET.has_key('confirm'): params = {'name': u"%s的%d个家伙腐败掉%.1f的证据" % (fee.group.name, len(fee.participants), fee.amount), 'confirm': "%s?confirm" % request.path, 'cancel': "/group/%s" % group_id,} return respond("confirm.html", params) require = check_user(fee.group) if require: return redirect("/redirect/?%s" % require) update_group_summary(fee, add_fee=False) fee.delete() except: raise else: return redirect("/redirect/group/%s" % group_id)
def delete(request, group_id): try: group = get_group(group_id) require = check_user(group) if require: raise Exception("invalid user") if not request.GET.has_key('confirm'): params = {'name': group.name, 'confirm': "%s?confirm" % request.path, 'cancel': "/group/%s" % group_id,} return respond("confirm.html", params) except ValueError: return redirect('/redirect/?param') except: return redirect("/redirect/?%s" % require) else: for member_id in group.members: member = get_user(member_id) member.delete() group.delete() return home(request)
def fetch_historic_values(request, listing_id): user = users.GetCurrentUser() if user is None: return http.HttpResponseForbidden('You must be signed in to view listing values') listing_values = None listing = None historic_results = None if listing_id: listing = get_listing(listing_id) listing_values = get_all_listing_values(listing.key()) start_date = datetime.date.today() - datetime.timedelta(days=60) for listing_value in listing_values: start_date = listing_value.date break historic_results = ystockquote.get_historical_prices( listing.symbol, start_date.strftime("%Y%m%d"), datetime.date.today().strftime("%Y%m%d")) for historic_result in historic_results: is_in_data_store = False split_date = historic_result[0].split('-') historic_date = datetime.date(int(split_date[0]), int(split_date[1]), int(split_date[2])) for data_store_value in listing_values: if historic_date == data_store_value.date: is_in_data_store = True if not is_in_data_store: lv = ListingValue(listing_key = str(listing.key()), date = historic_date, open = float(historic_result[1]), high = float(historic_result[2]), low = float(historic_result[3]), volume = int(historic_result[5]), adj_close = float(historic_result[6]), value = float(historic_result[4]), creator = user) lv.save() return common.respond(request, user, 'values_fetch', {'listing': listing})
def edit(request, listing_id): """Create or edit a listings. GET shows a blank form, POST processes it.""" user = users.GetCurrentUser() if user is None: return http.HttpResponseForbidden('You must be signed in to add or edit a listing') listing = None if listing_id: listing = db.get(db.Key.from_path(Listing.kind(), int(listing_id))) if listing is None: return http.HttpResponseNotFound('No listing exists with that key (%r)' % listing_id) form = ListingForm(data=request.POST or None, instance=listing) if not request.POST: return common.respond(request, user, 'listing', {'form': form, 'listing':listing}) errors = form.errors if not errors: try: listing = form.save(commit=False) except ValueError, err: errors['__all__'] = unicode(err)
flash = {} for entry in result: allocation = entry form = AllocationForm(data=request.POST or None, instance=allocation) if not request.POST: return common.respond(request, user, 'allocation', {'form': form, 'allocation': allocation, 'budget':TOTAL_BUDGET, 'flash': flash}) errors = form.errors if not errors: try: allocation = form.save(commit=False) except ValueError, err: errors['__all__'] = unicode(err) if errors: flash["message"] = "No change from default, I'll fix this sometime" return common.respond(request, user, 'allocation', {'form': form, 'allocation': allocation, 'budget':TOTAL_BUDGET, 'flash': flash}) if not allocation.creator: allocation.creator = user allocation.put() flash["message"] = "Allocations saved..." return common.respond(request, user, 'allocation', {'form': form, 'allocation': allocation, 'budget':TOTAL_BUDGET, 'flash': flash}) #return http.HttpResponseRedirect('/') def new(request): """Create and allocations entry . GET shows a blank form, POST processes it.""" return edit(request, None)
def lambda_handler(event, context): global TEAM_INFO global USER_INFO global NAME_MAP global PUBLIC_CHANNELS_INFO global sc global sms_controller global redis_client if not sc: sc = SlackClient(slack_client_token) if not USER_INFO: USER_INFO = get_member_info(client=sc) NAME_MAP = build_user_name_map(USER_INFO) if not USER_INFO: log.error( json.dumps( {"message": "unable to retrieve user info from slack api"})) if not sms_controller: sms_controller = APIController(username=FLOWROUTE_ACCESS_KEY, password=FLOWROUTE_SECRET_KEY) event_body = parse_qs(event['body']) if not event_body: event_body = json.loads(event['body']) log.debug( json.dumps({ "message": "the event body from slack", "event_body": event_body })) challenge = check_for_challenge(event_body) if challenge: return respond(None, challenge) token = unpack_token(event_body) if not token: event_body = json.loads(event_body['payload'][0]) token = event_body['token'] if token != slack_verification_token: log.error("Request token (%s) does not match expected", token) return respond(Exception('Invalid request token')) if 'command' in event_body: # It's a slash command command = event_body['command'][0] if command != COMMAND_WORD: return else: log.debug( json.dumps({ "message": "User triggered {} command, retrieving customer contact info." .format(COMMAND_WORD) })) user = event_body['user_name'][0] channel = event_body['channel_name'][0] command_text = unicode(event_body['text'][0]) user_id = event_body['user_id'] team_domain = event_body['team_domain'][0] # TODO get team id and channel id to load them into the cache try: recipient, text = command_text.split('@', 1)[1].split( ' ', 1) # FIXME support multiple recipients except [IndexError, KeyError]: log.error( json.dumps({ "message": "Could not parse the {} command".format(COMMAND_WORD) })) return respond(None, "Could not parse the command") try: recipient_number = USER_INFO[NAME_MAP[recipient]]['number'] if not recipient_number: raise KeyError('number') except KeyError: log.error( json.dumps({ "message": "Unable to find contact number for user {}. Refreshing global contact info before returning." .format(recipient) })) USER_INFO = get_member_info(client=sc) NAME_MAP = build_user_name_map(USER_INFO) return respond( None, "Could not find a phone number listed for that user. Please try again once they update their profile." ) else: log.info( json.dumps({ "message": "Found contact info for {}. Attempting SMS send.".format( recipient) })) content = MESSAGE_TEMPLATE.format(user=user, team=team_domain, channel=channel, body=emoji.emojize( text, use_aliases=True)) message = Message(to=recipient_number, from_=FLOWROUTE_NUMBER, content=content) try: sms_controller.create_message(message) except Exception as e: log.error( json.dumps({ "message": "Failed to send SMS", "exc": e })) return respond(None, "Unable to send SMS, please try again.") else: log.info( json.dumps({ "message": "Successfully sent SMS to {}".format(recipient) })) return respond(None, "Successfully sent SMS!") if event_body['type'] == 'interactive_message': log.info( json.dumps({ "message": ("Received interactive message event with callback_id {}." " Retrieving message context.").format( event_body['callback_id']) })) user_response = event_body['actions'][0].get('value') if user_response == 'no': return respond( None, "Ok, you can always message them with '/sms' if you change your mind later." ) else: if not redis_client: log.debug( json.dumps({ "message": "Getting redis client connection", "timestamp": str(arrow.get()) })) redis_client = get_redis_client() log.debug( json.dumps({ "message": "Got redis client connection", "timestamp": str(arrow.get()) })) try: message_context = redis_client.get(event_body['callback_id']) except Exception as e: log.error( json.dumps({ "message": "Failed to get event from Redis", "exc": e })) return respond(None, 'Something went wrong, please try again.') if not message_context: log.error( json.dumps({ "message": "Callback id {} not found in Redis".format( event_body['callback_id']) })) return respond(None, 'Session not found. Sorry!') else: event_context = json.loads(message_context) log.debug( json.dumps({ "message": "interactive event context", "context": event_context })) sender_id = event_context['sender'] channel_id = event_context['channel'] for recipient in event_context['recipients']: try: recipient_number = USER_INFO[recipient]['number'] recipient_name = USER_INFO[recipient]['name'] except KeyError: log.warning( json.dumps({ "message": "Unable to find contact number for user {}. Refreshing global contact info before returning." .format(recipient) })) USER_INFO = get_member_info(client=sc) NAME_MAP = build_user_name_map(USER_INFO) try: recipient_number = USER_INFO[recipient]['number'] recipient_name = USER_INFO[recipient]['name'] except KeyError: log.debug( json.dumps({ "message": "unable to find contact number for user", "recipient_id": recipient, "user_info": USER_INFO, "name_map": NAME_MAP, "context": event_context })) log.error( json.dumps({ "message": "Unable to find contact number for user {}. Returning now." .format(recipient) })) return ( None, "Could not find a contact number for that user." ) if not recipient_number: log.info( json.dumps({ "message": "Could not find a contact number for {}". format(recipient_name) })) return ( None, "Could not find a contact number for that user on their profile." ) try: sender_info = USER_INFO.get(sender_id) if not sender_info: log.debug( json.dumps({ "message": "unable to find contact number for user", "channel_id": channel_id, "sender_id": sender_id, "user_info": USER_INFO, "name_map": NAME_MAP, "context": event_context })) return ( None, "Could not find info for that user. Please try again." ) else: sender_name = sender_info['name'] team_domain = TEAM_INFO.get('team_domain') if not team_domain: TEAM_INFO = get_team_info(client=sc) team_domain = TEAM_INFO['team_domain'] channel_info = PUBLIC_CHANNELS_INFO.get(channel_id) if not channel_info: PUBLIC_CHANNELS_INFO.update( get_channel_info(channel_id, client=sc)) channel_name = PUBLIC_CHANNELS_INFO[channel_id][ 'name'] else: channel_name = PUBLIC_CHANNELS_INFO[channel_id][ 'name'] except Exception as e: log.error( json.dumps({ "message": "unable to get information", "channel_id": channel_id, "sender_id": sender_id, "user_info": USER_INFO, "name_map": NAME_MAP, "channel_info": PUBLIC_CHANNELS_INFO, "team_info": TEAM_INFO, "context": event_context, "exc": str(e) })) raise e log.info( json.dumps({ "message": "Found contact info for {}. Attempting SMS send.". format(recipient_name) })) human_readable_message = event_context['message'].replace( '<@{}>'.format(recipient), "@{}".format(recipient_name)) log.debug( json.dumps({ "message": "sms message", "sms": human_readable_message })) content = MESSAGE_TEMPLATE.format( user=sender_name, team=team_domain, channel=channel_name, body=emoji.emojize(human_readable_message, use_aliases=True)) message = Message(to=recipient_number, from_=FLOWROUTE_NUMBER, content=content) try: sms_controller.create_message(message) except Exception as e: log.error( json.dumps({ "message": "Failed to send SMS", "exc": str(e) })) return respond( None, "Unable to send SMS, please try again.") else: log.info( json.dumps({ "message": "Successfully sent SMS to {}".format(recipient) })) return respond(None, "Successfully sent!") elif event_body['type'] == 'event_callback': log.debug( json.dumps({ "message": "event callback body", "body": event_body })) # It's a channel message event event = event_body['event'] # TODO make sure this isn't a duplicate request event_id = event_body['event_id'] if event['type'] == 'message': if event_body.get('subtype') == 'message_changed' and event.get( 'hidden') == True: # This is the ephemeral message change that # was just posted back. return try: text = event['text'] except Exception as e: log.info( json.dumps({ "message": "unknown message event with no text", "body": event_body })) return # lookup channel, team, and user channel = event['channel'] sender = event['user'] timestamp = event['ts'] mentioned_users = look_for_mentions(text) if mentioned_users: away_users = [] for user_id in mentioned_users: presence = get_user_presence(user_id, client=sc) log.debug( json.dumps({ "message": "Found mentioned user {} in '{}' public channel message with status {}." .format(user_id, channel, presence) })) if presence != 'active': away_users.append(user_id) else: log.debug( json.dumps({ "message": "Found no mentioned users in '{}' public channel message" .format(channel) })) return if away_users: users_have_numbers = False for recipient in away_users: try: recipient_number = USER_INFO[recipient]['number'] recipient_name = USER_INFO[recipient]['name'] except KeyError: log.warning( json.dumps({ "message": "Unable to find contact number for user {}. Refreshing global" " contact info before returning.".format( recipient) })) USER_INFO = get_member_info(client=sc) NAME_MAP = build_user_name_map(USER_INFO) else: if recipient_number: log.debug( json.dumps({ "message": "Found number of away users", "user_id": recipient, "number": recipient_number })) users_have_numbers = True if not users_have_numbers: log.info({ "message": "None of the away users mentioned have phone numbers listed." }) return log.info( json.dumps({ "message": "Found {} non-active users in '{}' public channel message. Sending message prompt." .format(len(away_users), channel), "users": away_users })) if not redis_client: log.debug( json.dumps({ "message": "Getting redis client connection", "timestamp": str(arrow.get()) })) redis_client = get_redis_client() log.debug( json.dumps({ "message": "Got redis client connection", "timestamp": str(arrow.get()) })) store_event_context(event_id, channel, sender, away_users, timestamp, text, client=redis_client) send_message_prompt(event_id, sender, channel, client=sc) log.info( json.dumps({ "message": "Successfully posted ephemeral prompt to {} in channel {}" .format(sender, channel), "callback_id": event_id })) return respond(None, 'Successfully sent prompt') else: log.debug( json.dumps({ "message": "Found no away users in '{}' public channel message mentions." })) return
def home(request): fees = get_fees() params = { 'fees': fees, } return respond('home.html', params)
def page_not_found(request): return respond('404.html')
def index(request): user = users.GetCurrentUser() return common.respond(request, user, 'index')
return http.HttpResponseNotFound('No listing exists with that key (%r)' % listing_id) form = ListingForm(data=request.POST or None, instance=listing) if not request.POST: return common.respond(request, user, 'listing', {'form': form, 'listing':listing}) errors = form.errors if not errors: try: listing = form.save(commit=False) except ValueError, err: errors['__all__'] = unicode(err) if errors: return common.respond(request, user, 'listing', {'form': form, 'listing': listing}) if not listing.creator: listing.creator = user listing.put() return http.HttpResponseRedirect('/') def new(request): """Create a listing. GET shows a blank form, POST processes it.""" return edit(request, None) def delete(request ,listing_id): """Delete a listing.""" if request.DELETE: return http.HttpResponseRedirect('/')
def list(request): user = users.GetCurrentUser() listings = db.GqlQuery('SELECT * FROM Listing ORDER BY created DESC') return common.respond(request, user, 'list', {'listings': listings })