class DashboardHandler(BaseHandler): businessDao = DaoFactory.create_rw_businessDao() eventDao = DaoFactory.create_rw_eventDao() childeventDao = DaoFactory.create_rw_childeventDao() playgroundDao = DaoFactory.create_rw_playgroundDao() trainingcentreDao = DaoFactory.create_rw_trainingCentreDao() matchDao = DaoFactory.create_rw_matchDao() teamDao = DaoFactory.create_rw_teamDao() playerDao = DaoFactory.create_rw_playerDao() @user_required def get(self, business_id=None): params = {} params['title'] = 'Dashboard' params['owner_business'] = self.businessDao.query_by_owner( self.user_info) params['owner_playgrounds'] = self.playgroundDao.query_by_owner( self.user_info) params['owner_events'] = self.eventDao.query_by_owner(self.user_info) params['owner_childevents'] = self.childeventDao.query_by_owner( self.user_info) params[ 'owner_trainingcentres'] = self.trainingcentreDao.query_by_owner( self.user_info) params['owner_matches'] = self.matchDao.query_by_owner(self.user_info) params['owner_teams'] = self.teamDao.query_by_owner(self.user_info) params['owner_players'] = self.playerDao.query_by_owner(self.user_info) return self.render_template('/cms/dashboard.html', **params)
class ManageBulkDataHandler(blobstore_handlers.BlobstoreUploadHandler, BaseHandler): bulkdataDao = DaoFactory.create_rw_bulkdataDao() businessDao = DaoFactory.create_rw_businessDao() mediaDao = DaoFactory.create_rw_mediaDao() @user_required def get(self, masterdata_id=None): params = {} upload_url = self.uri_for('create-bulk-data') continue_url = self.request.get('continue').encode('ascii', 'ignore') status = self.request.get('status') pg_status = status if status != '' else None params['title'] = 'Create Bulk Data' params['weekdays'] = constants.DAYS_LIST if masterdata_id is not None and len(masterdata_id) > 1: masterdata = self.playgroundDao.get_record(masterdata_id) params['title'] = 'Update - ' + str(masterdata.name) params['continue_url'] = continue_url if pg_status is not None: logger.info('current status: %s' % pg_status) key = self.playgroundDao.status_change(masterdata, self.user_info) if key is not None: updated_pg = self.playgroundDao.get_record(long(key.id())) logger.info('updated status : %s' % updated_pg.status) if pg_status == str(updated_pg.status): logger.info('masterdata status could not be changed.') message = ('masterdata status could not be changed.') self.add_message(message, 'error') else: logger.info('masterdata status succesfully changed.') message = ('masterdata status succesfully changed.') self.add_message(message, 'success') return self.redirect(continue_url) else: upload_url = self.uri_for('edit-masterdata', masterdata_id=masterdata_id) all_media = self.mediaDao.get_all_media( masterdata.key, constants.PLAYGROUND) current_media = [] for photo in all_media: current_media.append({ 'name': photo.name, 'url': images.get_serving_url(photo.link), 'status': photo.status, 'primary': photo.primary }) params['current_media'] = current_media self.form = cms_utils.dao_to_form_locality_info( masterdata, forms.BulkPlaygroundForm(self, masterdata)) self.form = cms_utils.dao_to_form_contact_info( masterdata, self.form) params['media_upload_url'] = blobstore.create_upload_url(upload_url) return self.render_template('/cms/create_bulk_data.html', **params) @user_required def post(self, masterdata_id=None): params = {} if not self.form.validate(): if masterdata_id is not None and len(masterdata_id) > 1: return self.get(masterdata_id) else: return self.get() save = self.request.get('save') next = self.request.get('next') next_tab = next if next != '' else save locality_id = self.request.get('locality_id') masterdata = self.form_to_dao(masterdata_id) if locality_id is not None: logger.info('Locality Id: %s ' % locality_id) locality_count = self.process_locality(masterdata.address.locality, locality_id, constants.PLACES_API_KEY) masterdata.address.locality_id = locality_id logger.debug('masterdata populated ' + str(masterdata)) key = self.bulkdataDao.persist(masterdata, self.user_info) logger.debug('key ' + str(key)) if key is not None: self.upload_photos(key) logger.info('masterdata succesfully created/updated') message = ('masterdata succesfully created/updated.') self.add_message(message, 'success') return self.redirect_to('create-bulk-data', **params) logger.error('masterdata creation failed') message = ('masterdata creation failed.') self.add_message(message, 'error') self.form = forms.MasterDataForm(self, masterdata) return self.render_template('/cms/create_bulk_data.html', **params) @webapp2.cached_property def form(self): return forms.MasterDataForm(self) def upload_photos(self, key): upload_files = self.get_uploads() if upload_files is not None and len(upload_files) > 0: files_count = len(upload_files) logger.info('no of files uploaded ' + str(files_count)) for x in xrange(files_count): blob_info = upload_files[x] media_obj = Media() media_obj.name = self.form.media.__getitem__(x).data['name'] media_obj.type = constants.PHOTO media_obj.status = self.form.media.__getitem__( x).data['status'] media_obj.primary = self.form.media.__getitem__( x).data['primary'] media_obj.link = blob_info.key() media_obj.url = images.get_serving_url(blob_info.key()) media_obj.entity_id = key media_obj.entity_type = constants.PLAYGROUND self.mediaDao.persist(media_obj) logger.info('Link to picture file ' + media_obj.name + ', ' + images.get_serving_url(media_obj.link)) def form_to_dao(self, masterdata_id): masterdata = None if masterdata_id is not None and len(masterdata_id) > 1: masterdata = self.playgroundDao.get_record(long(masterdata_id)) else: masterdata = MasterData() masterdata.pg_name = self.form.pg_name.data masterdata.sport = self.form.sport.data.lower() masterdata.public = self.form.public.data masterdata.booking_days = self.form.booking_days.data masterdata.regular_time = self.form.regular_time.data masterdata.ground_type = self.form.ground_type.data.lower() masterdata.surface_type = self.form.surface_type.data.lower() masterdata.tot_fields = self.form.tot_fields.data masterdata.ground_rules = self.form.ground_rules.data.lower() masterdata.tc_name = self.form.tc_name.data masterdata.tc_open_days = self.form.tc_open_days.data.lower() masterdata.age_limit = self.form.age_limit.data masterdata.tc_participants = self.form.tc_participants.data masterdata.se_name = self.form.se_name.data if self.form.start_datetime.data is not None: masterdata.start_datetime = datetime( *(self.form.start_datetime.data.timetuple()[:6])) if self.form.end_datetime.data is not None: masterdata.end_datetime = datetime( *(self.form.end_datetime.data.timetuple()[:6])) masterdata = cms_utils.form_to_dao_address(self.form, masterdata) masterdata = cms_utils.form_to_dao_contact_pg(self.form, masterdata) masterdata = cms_utils.form_to_dao_contact_tc(self.form, masterdata) masterdata = cms_utils.form_to_dao_contact_se(self.form, masterdata) return masterdata def create_or_update_business(self, playground): if playground.business_id is not None: business = self.businessDao.get_record( long(playground.business_id.id())) else: business = Business() business.name = playground.name business.alias = playground.alias business.description = playground.description business.contact_info = playground.contact_info return business
class ManageEventHandler(blobstore_handlers.BlobstoreUploadHandler, BaseHandler): businessDao = DaoFactory.create_rw_businessDao() eventDao = DaoFactory.create_rw_eventDao() mediaDao = DaoFactory.create_rw_mediaDao() #@role_required('business') @user_required def get(self, business_id=None, event_id=None): params = {} upload_url = self.uri_for('select-for-event') continue_url = self.request.get('continue').encode('ascii', 'ignore') params[ 'continue_url'] = continue_url if continue_url != '' else upload_url status = self.request.get('status') event_status = status if status != '' else None params['title'] = 'Create New Event' if business_id is not None and len(business_id) > 1: self.form.business_id = business_id if event_id is not None and len(event_id) > 1: event = self.eventDao.get_record(event_id) params['title'] = 'Update - ' + str(event.name) if event_status is not None: logger.info('current status: %s' % event_status) key = self.eventDao.status_change(event, self.user_info) if key is not None: updated_event = self.eventDao.get_record(long( key.id())) logger.info('updated status : %s' % updated_event.status) if event_status == str(updated_event.status): logger.info('event status could not be changed.') message = ('event status could not be changed.') self.add_message(message, 'error') else: logger.info('event status succesfully changed.') message = ('event status succesfully changed.') self.add_message(message, 'success') return self.redirect(continue_url) else: upload_url = self.uri_for('edit-event', business_id=business_id, event_id=event_id) all_media = self.mediaDao.get_all_media( event.key, constants.EVENT) current_media = [] for photo in all_media: current_media.append({ 'name': photo.name, 'url': images.get_serving_url(photo.link), 'status': photo.status, 'primary': photo.primary }) params['current_media'] = current_media logger.debug('event detail ' + str(event)) self.form = cms_utils.dao_to_form_city_info( event, forms.EventForm(self, event)) self.form = cms_utils.dao_to_form_contact_info( event, self.form) params['media_upload_url'] = blobstore.create_upload_url( upload_url) return self.render_template('/cms/create_event.html', **params) else: upload_url = self.uri_for('create-event', business_id=business_id) params['media_upload_url'] = blobstore.create_upload_url( upload_url) return self.render_template('/cms/create_event.html', **params) params['entity_name'] = 'Event' params['owner_business'] = self.businessDao.query_by_owner( self.user_info) logger.info('Result Params : ' + str(params['entity_name'])) return self.render_template('/cms/select_business.html', **params) #@role_required('business') @user_required def post(self, business_id=None, event_id=None): params = {} if not self.form.validate(): if business_id is not None and len(business_id) > 0: if event_id is not None and len(event_id) > 0: return self.get(business_id, event_id) else: return self.get(business_id) else: return self.get() save = self.request.get('save') next_fill = self.request.get('next') next_tab = next_fill if next_fill != '' else save locality_id = self.request.get('locality_id') event = self.form_to_dao(event_id) if locality_id is not None and len(locality_id) > 0: logger.info('Locality Id: %s ' % locality_id) locality_count = self.process_locality(event.address.locality, locality_id, constants.PLACES_API_KEY) event.address.locality_id = locality_id else: event.address.locality = '' event.address.locality_id = '' logger.debug('event populated ' + str(event)) if business_id != None and business_id != 'user': business = self.businessDao.get_record(business_id) business_key = business.key else: business = self.create_or_update_business(event) business_key = self.businessDao.persist(business, self.user_info) if business_key is not None: logger.info('Business succesfully created for event, ' + business.name) event.business_id = business_key key = self.eventDao.persist(event, self.user_info) logger.debug('key ' + str(key)) if key is not None: self.upload_photos(key) logger.info('event succesfully created/updated') message = ('event succesfully created/updated.') self.add_message(message, 'success') if next_tab is not None: if next_tab != 'save': redirect_url = self.uri_for( 'edit-event', business_id=event.business_id.id(), event_id=key.id()) redirect_url = redirect_url + next_tab logger.info('Url %s' % redirect_url) return self.redirect(redirect_url) else: redirect_url = self.uri_for( 'event-details', city_name=event.address.city, entity_id=key.id(), entity_alias=event.alias) return self.redirect(redirect_url) #return self.redirect_to('dashboard', **params) logger.error('event creation failed') message = ('event creation failed.') self.add_message(message, 'error') self.form = forms.EventForm(self, event) return self.render_template('/cms/create_event.html', **params) @webapp2.cached_property def form(self): return forms.EventForm(self) def upload_photos(self, key): upload_files = self.get_uploads() if upload_files is not None and len(upload_files) > 0: files_count = len(upload_files) logger.info('no of files uploaded ' + str(files_count)) for x in xrange(files_count): blob_info = upload_files[x] media_obj = Media() media_obj.name = self.form.media.__getitem__(x).data['name'] media_obj.type = constants.PHOTO media_obj.status = self.form.media.__getitem__( x).data['status'] media_obj.primary = self.form.media.__getitem__( x).data['primary'] media_obj.link = blob_info.key() media_obj.url = images.get_serving_url(blob_info.key()) media_obj.entity_id = key media_obj.entity_type = constants.EVENT self.mediaDao.persist(media_obj) logger.info('Link to picture file ' + media_obj.name + ', ' + images.get_serving_url(media_obj.link)) def form_to_dao(self, event_id): event = None if event_id is not None and len(event_id) > 1: event = self.eventDao.get_record(long(event_id)) else: event = Event() event.name = self.form.name.data event.sport = self.form.sport.data #Create an automatic alias for the event event.alias = utils.slugify(self.form.name.data) event.caption = self.form.caption.data event.description = self.form.description.data event.featured = self.form.featured.data event.start_datetime = datetime( *(self.form.start_datetime.data.timetuple()[:6])) event.end_datetime = datetime( *(self.form.end_datetime.data.timetuple()[:6])) self.form.address.city.data = self.form.city.data #for city from basic info to address event = cms_utils.form_to_dao_address(self.form, event) event = cms_utils.form_to_dao_contact_info(self.form, event) return event def create_or_update_business(self, event): if event.business_id is not None: business = self.businessDao.get_record(long( event.business_id.id())) else: business = Business() business.name = event.name business.description = event.description business.alias = event.alias business.contact_info = event.contact_info return business
class ManageTrainingCentreHandler(blobstore_handlers.BlobstoreUploadHandler, BaseHandler): businessDao = DaoFactory.create_rw_businessDao() trainingCentreDao = DaoFactory.create_rw_trainingCentreDao() mediaDao = DaoFactory.create_rw_mediaDao() #@role_required('business') @user_required def get(self, business_id=None, trainingcentre_id=None): params = {} upload_url = self.uri_for('select-for-trainingcentre') continue_url = self.request.get('continue').encode('ascii', 'ignore') status = self.request.get('status') tc_status = status if status != '' else None params['title'] = 'Create New Training Centre' if business_id is not None and len(business_id) > 1: self.form.business_id = business_id params['continue_url'] = continue_url if trainingcentre_id is not None and len(trainingcentre_id) > 1: trainingcentre = self.trainingCentreDao.get_record( trainingcentre_id) params['title'] = 'Update - ' + str(trainingcentre.name) if tc_status is not None: logger.info('current status: %s' % tc_status) key = self.trainingCentreDao.status_change( trainingcentre, self.user_info) if key is not None: updated_tc = self.trainingCentreDao.get_record( long(key.id())) logger.info('updated status : %s' % updated_tc.status) if tc_status == str(updated_tc.status): logger.info( 'trainingcentre status could not be changed.') message = ( 'trainingcentre status could not be changed.') self.add_message(message, 'error') else: logger.info( 'trainingcentre status succesfully changed.') message = ( 'trainingcentre status succesfully changed.') self.add_message(message, 'success') return self.redirect(continue_url) else: upload_url = self.uri_for( 'edit-trainingcentre', business_id=business_id, trainingcentre_id=trainingcentre_id) all_media = self.mediaDao.get_all_media( trainingcentre.key, constants.TRAINING_CENTRE) current_media = [] for photo in all_media: current_media.append({ 'name': photo.name, 'url': images.get_serving_url(photo.link), 'status': photo.status, 'primary': photo.primary }) params['current_media'] = current_media self.form = cms_utils.dao_to_form_locality_info( trainingcentre, forms.TrainingCentreForm(self, trainingcentre)) self.form = cms_utils.dao_to_form_contact_info( trainingcentre, self.form) params['media_upload_url'] = blobstore.create_upload_url( upload_url) return self.render_template('/cms/create_trainingcenter.html', **params) else: upload_url = self.uri_for('create-trainingcentre', business_id=business_id) params['media_upload_url'] = blobstore.create_upload_url( upload_url) return self.render_template('/cms/create_trainingcenter.html', **params) params['continue_url'] = upload_url params['entity_name'] = 'Training Centre' params['owner_business'] = self.businessDao.query_by_owner( self.user_info) return self.render_template('/cms/select_business.html', **params) #@role_required('business') @user_required def post(self, business_id=None, trainingcentre_id=None): params = {} if not self.form.validate(): if business_id is not None and len(business_id) > 0: if trainingcentre_id is not None and len( trainingcentre_id) > 0: return self.get(business_id, trainingcentre_id) else: return self.get(business_id) else: return self.get() save = self.request.get('save') next_fill = self.request.get('next') next_tab = next_fill if next_fill != '' else save locality_id = self.request.get('locality_id') trainingcentre = self.form_to_dao(trainingcentre_id) logger.info('This is debugging for %s' % trainingcentre) if locality_id is not None: logger.info('Locality Id: %s ' % locality_id) locality_count = self.process_locality( trainingcentre.address.locality, locality_id, constants.PLACES_API_KEY) trainingcentre.address.locality_id = locality_id logger.debug('trainingcentre populated ' + str(trainingcentre)) if business_id != None and business_id != 'user': business = self.businessDao.get_record(business_id) business_key = business.key else: business = self.create_or_update_business(trainingcentre) business_key = self.businessDao.persist(business, self.user_info) if business_key is not None: logger.info('Business succesfully created for trainingcentre, ' + business.name) trainingcentre.business_id = business_key key = self.trainingCentreDao.persist(trainingcentre, self.user_info) logger.debug('key ' + str(key)) if key is not None: self.upload_photos(key) logger.info('trainingcentre succesfully created/updated') message = ('trainingcentre succesfully created/updated.') self.add_message(message, 'success') if next_tab is not None: if next_tab != 'save': redirect_url = self.uri_for( 'edit-trainingcentre', business_id=trainingcentre.business_id.id(), trainingcentre_id=key.id()) logger.debug('this is redirect value: %s' % redirect_url) redirect_url = redirect_url + next_tab logger.info('Redirect Url %s' % redirect_url) return self.redirect(redirect_url) else: redirect_url = self.uri_for( 'tc-details', city_name=trainingcentre.address.city, locality_name=trainingcentre.address.locality, entity_id=key.id(), entity_alias=trainingcentre.alias) return self.redirect(redirect_url) #return self.redirect_to('dashboard', **params) logger.error('trainingcentre creation failed') message = ('trainingcentre creation failed.') self.add_message(message, 'error') self.form = forms.TrainingCentreForm(self, trainingcentre) return self.render_template('/cms/create_trainingcentre.html', **params) @webapp2.cached_property def form(self): return forms.TrainingCentreForm(self) def upload_photos(self, key): upload_files = self.get_uploads() if upload_files is not None and len(upload_files) > 0: files_count = len(upload_files) logger.info('no of files uploaded ' + str(files_count)) for x in xrange(files_count): blob_info = upload_files[x] media_obj = Media() media_obj.name = self.form.media.__getitem__(x).data['name'] media_obj.type = constants.PHOTO media_obj.status = self.form.media.__getitem__( x).data['status'] media_obj.primary = self.form.media.__getitem__( x).data['primary'] media_obj.link = blob_info.key() media_obj.url = images.get_serving_url(blob_info.key()) media_obj.entity_id = key media_obj.entity_type = constants.TRAINING_CENTRE self.mediaDao.persist(media_obj) logger.info('Link to picture file ' + media_obj.name + ', ' + images.get_serving_url(media_obj.link)) def form_to_dao(self, trainingcentre_id): trainingcentre = None if trainingcentre_id is not None and len(trainingcentre_id) > 1: trainingcentre = self.trainingCentreDao.get_record( long(trainingcentre_id)) else: trainingcentre = TrainingCentre() trainingcentre.name = self.form.name.data trainingcentre.sport = self.form.sport.data #Create an automatic alias for the trainingcentre trainingcentre.alias = utils.slugify(self.form.name.data) trainingcentre.description = self.form.description.data trainingcentre.featured = self.form.featured.data self.form.address.locality.data = self.form.locality.data #for locality from basic info to address self.form.address.city.data = self.form.city.data #for city from basic info to address trainingcentre = cms_utils.form_to_dao_address(self.form, trainingcentre) trainingcentre = cms_utils.form_to_dao_contact_info( self.form, trainingcentre) return trainingcentre def create_or_update_business(self, trainingcentre): if trainingcentre.business_id is not None: business = self.businessDao.get_record( long(trainingcentre.business_id.id())) else: business = Business() business.name = trainingcentre.name business.description = trainingcentre.description business.alias = trainingcentre.alias business.contact_info = trainingcentre.contact_info return business
class ManagePlaygroundHandler(blobstore_handlers.BlobstoreUploadHandler, BaseHandler): playgroundDao = DaoFactory.create_rw_playgroundDao() businessDao = DaoFactory.create_rw_businessDao() mediaDao = DaoFactory.create_rw_mediaDao() @user_required def get(self, playground_id=None): params = {} upload_url = self.uri_for('create-playground') continue_url = self.request.get('continue').encode('ascii', 'ignore') status = self.request.get('status') pg_status = status if status != '' else None params['title'] = 'Create New Playground' if playground_id is not None and len(playground_id) > 1: playground = self.playgroundDao.get_record(playground_id) params['title'] = 'Update - ' + str(playground.name) params['continue_url'] = continue_url if pg_status is not None: logger.info('current status: %s' % pg_status) key = self.playgroundDao.status_change(playground, self.user_info) if key is not None: updated_pg = self.playgroundDao.get_record(long(key.id())) logger.info('updated status : %s' % updated_pg.status) if pg_status == str(updated_pg.status): logger.info('playground status could not be changed.') message = ('playground status could not be changed.') self.add_message(message, 'error') else: logger.info('playground status succesfully changed.') message = ('playground status succesfully changed.') self.add_message(message, 'success') return self.redirect(continue_url) else: upload_url = self.uri_for('edit-playground', playground_id = playground_id) all_media = self.mediaDao.get_all_media(playground.key, constants.PLAYGROUND) current_media = [] for photo in all_media: current_media.append({'name': photo.name, 'url':images.get_serving_url(photo.link), 'status': photo.status, 'primary': photo.primary}) params['current_media'] = current_media self.form = cms_utils.dao_to_form_locality_info(playground, forms.PlaygroundForm(self, playground)) self.form = cms_utils.dao_to_form_contact_info(playground, self.form) params['media_upload_url'] = blobstore.create_upload_url(upload_url) return self.render_template('/cms/create_playground.html', **params) @user_required def post(self, playground_id=None): params = {} if not self.form.validate(): if playground_id is not None and len(playground_id) > 1: return self.get(playground_id) else: return self.get() save = self.request.get('save') next = self.request.get('next') next_tab = next if next != '' else save locality_id = self.request.get('locality_id') playground = self.form_to_dao(playground_id) if locality_id is not None: logger.info('Locality Id: %s ' % locality_id) locality_count = self.process_locality(playground.address.locality, locality_id, constants.PLACES_API_KEY) playground.address.locality_id = locality_id logger.debug('playground populated ' + str(playground)) business = self.create_or_update_business(playground) business_key = self.businessDao.persist(business, self.user_info) if business_key is not None: logger.info('Business succesfully created for playground, ' + business.name) playground.business_id = business_key key = self.playgroundDao.persist(playground, self.user_info) logger.debug('key ' + str(key)) if key is not None: self.upload_photos(key) logger.info('playground succesfully created/updated') message = ('playground succesfully created/updated.') self.add_message(message, 'success') if next_tab is not None: if next_tab != 'save': redirect_url = self.uri_for('edit-playground', playground_id = key.id()) redirect_url = redirect_url + next_tab logger.info('Redirect Url %s' % redirect_url) return self.redirect(redirect_url) else: redirect_url = self.uri_for('pg-details', city_name = playground.address.city, locality_name = playground.address.locality, entity_id = key.id(), entity_alias = playground.alias) return self.redirect(redirect_url) #return self.redirect_to('dashboard', **params) logger.error('playground creation failed') message = ('playground creation failed.') self.add_message(message, 'error') self.form = forms.PlaygroundForm(self, playground) return self.render_template('/cms/create_playground.html', **params) @webapp2.cached_property def form(self): return forms.PlaygroundForm(self) def upload_photos(self, key): upload_files = self.get_uploads() if upload_files is not None and len(upload_files) > 0: files_count = len(upload_files) logger.info('no of files uploaded ' + str(files_count)) for x in xrange(files_count): blob_info = upload_files[x] media_obj = Media() media_obj.name = self.form.media.__getitem__(x).data['name'] media_obj.type = constants.PHOTO media_obj.status = self.form.media.__getitem__(x).data['status'] media_obj.primary = self.form.media.__getitem__(x).data['primary'] media_obj.link = blob_info.key() media_obj.url = images.get_serving_url(blob_info.key()) media_obj.entity_id = key media_obj.entity_type = constants.PLAYGROUND self.mediaDao.persist(media_obj) logger.info('Link to picture file ' + media_obj.name + ', ' + images.get_serving_url(media_obj.link)) def form_to_dao(self, playground_id): playground = None if playground_id is not None and len(playground_id) > 1: playground = self.playgroundDao.get_record(long(playground_id)) else: playground = Playground() playground.name = self.form.name.data playground.sport = self.form.sport.data.lower() #Create an automatic alias for the playground playground.alias = utils.slugify(self.form.name.data) playground.description = self.form.description.data playground.featured = self.form.featured.data self.form.address.locality.data = self.form.locality.data #for locality from basic info to address self.form.address.city.data = self.form.city.data #for city from basic info to address playground = cms_utils.form_to_dao_address(self.form, playground) playground = cms_utils.form_to_dao_contact_info(self.form, playground) return playground def create_or_update_business(self, playground): if playground.business_id is not None: business = self.businessDao.get_record(long(playground.business_id.id())) else: business = Business() business.name = playground.name business.description = playground.description business.alias = playground.alias business.contact_info = playground.contact_info return business
class ManageBusinessHandler(blobstore_handlers.BlobstoreUploadHandler, BaseHandler): businessDao = DaoFactory.create_rw_businessDao() @role_required('business') def get(self, business_id=None): params = {} params['title'] = 'Create New Business' upload_url = self.uri_for('create-business') if business_id is not None and len(business_id) > 1: upload_url = self.uri_for('edit-business', business_id=business_id) business = self.businessDao.get_record(business_id) params['title'] = 'Update - ' + str(business.name) if business.logo: params['current_logo'] = images.get_serving_url(business.logo) self.form = cms_utils.dao_to_form_contact_info( business, forms.BusinessForm(self, business)) logger.debug('upload_url' + upload_url) params['media_upload_url'] = blobstore.create_upload_url(upload_url) return self.render_template('/cms/create_business.html', **params) @role_required('business') def post(self, business_id=None): params = {} if not self.form.validate(): if business_id is not None and len(business_id) > 1: return self.get(business_id) else: return self.get() business = self.form_to_dao(business_id) upload_files = self.get_uploads( 'logo') # 'logo' is file upload field in the form if upload_files is not None and len(upload_files) > 0: blob_info = upload_files[0] business.logo = blob_info.key() logger.info('Link to logo ' + images.get_serving_url(business.logo)) logger.debug('business populated ' + str(business)) key = self.businessDao.persist(business, self.user_info) logger.debug('key ' + str(key)) if key is not None: logger.info('Business succesfully created/updated') message = ('Business succesfully created/updated.') self.add_message(message, 'success') return self.redirect_to('dashboard', **params) else: logger.error('business creation failed') message = ('Business creation failed.') self.add_message(message, 'error') self.form = forms.BusinessForm(self, business) return self.render_template('/cms/create_business.html', **params) @webapp2.cached_property def form(self): return forms.BusinessForm(self) def form_to_dao(self, business_id): business = None if business_id is not None and len(business_id) > 1: business = self.businessDao.get_record(long(business_id)) logger.debug('business ' + str(business)) else: business = Business() logger.debug('business 2 ' + str(business)) business.name = self.form.name.data #Create an automatic alias for the business business.alias = utils.slugify(self.form.name.data) business.description = self.form.description.data return cms_utils.form_to_dao_contact_info(self.form, business)
class ImportHandler(blobstore_handlers.BlobstoreUploadHandler, BaseHandler): eventDao = DaoFactory.create_rw_eventDao() businessDao = DaoFactory.create_rw_businessDao() playgroundDao = DaoFactory.create_rw_playgroundDao() trainingCentreDao = DaoFactory.create_rw_trainingCentreDao() @user_required def get(self): params = {} upload_url = self.uri_for('import') params['title'] = 'Import' params['media_upload_url'] = blobstore.create_upload_url(upload_url) return self.render_template('/cms/import.html', **params) @user_required def post(self): if not self.form.validate(): return self.get() start_record = int(str(self.request.get('linenum'))) upload_files = self.get_uploads( 'importfile') # 'file' is file upload field in the form blob_info = upload_files[0] upload_count = self.process_csv(blob_info, start_record) self.add_message( str(upload_count) + ' entities created successfully.', 'success') return self.redirect_to('import') def process_csv(self, blob_info, start_record): update = {} upload_count = 0 row_count = 0 blob_reader = blobstore.BlobReader(blob_info.key()) datareader = csv.reader(blob_reader) for row in datareader: row_count += 1 if row_count >= (start_record + 1): #to skip the header row logger.info('Starting to parse %s, %s' % (row_count, row[1])) entity_type = row[0].lower() update['name'] = utils.stringify(row[1]) # Name is mandatory for all entities if update['name'] == '': logger.error('Name is empty. Skipping this record') continue update['locality'] = utils.stringify(row[5]).lower() update['city'] = utils.stringify(row[8]).lower() #Locality and city mandatory for playground and trainingcentre if entity_type != 'event': if update['locality'] == '' or update['city'] == '': logger.error( 'Locality or city is empty. Skipping this record') continue alias_name = utils.slugify(update['name'].lower()) try: update['description'] = utils.stringify(row[2]) update['sport'] = utils.stringify(row[3]).lower() update['person_name'] = utils.stringify(row[10]) update['phone'] = utils.stringify(row[11]) update['email'] = utils.stringify(row[12]) update['website'] = utils.stringify(row[13]) update['facebook'] = utils.stringify(row[18]) update['twitter'] = utils.stringify(row[19]) update['youtube'] = utils.stringify(row[20]) update['gplus'] = utils.stringify(row[21]) update['line1'] = utils.stringify(row[6]) update['line2'] = utils.stringify(row[7]) update['pin'] = int( row[9].strip()) if row[9] != '' else None #update['start_datetime'] = row[22] #update['end_datetime'] = row[23] logger.debug('Constructed Structure for upload ' + str(update)) logger.info('Entity type to be created, ' + entity_type) if entity_type == 'ground': import_data = self.form_to_dao_ground( alias_name, **update) elif entity_type == 'club': import_data = self.form_to_dao_center( alias_name, **update) elif entity_type == 'event': import_data = self.form_to_dao_event( alias_name, **update) # for add locality table if import_data.address.locality != '': place_name = import_data.address.locality logger.info('Place: %s' % place_name) newfeed_url = 'https://maps.googleapis.com/maps/api/place/autocomplete/xml?types=(regions)&input=' + urllib.quote( place_name) + '&key=' + constants.PLACES_API_KEY logging.info('newfeed url %s' % newfeed_url) newroot = self.parse(newfeed_url) auto_status = newroot.getElementsByTagName( 'status')[0].firstChild.data logger.info('Auto Status: %s ' % auto_status) if auto_status == 'OK': items = newroot.getElementsByTagName( 'prediction')[0] place_id = items.getElementsByTagName( 'place_id')[0].firstChild.data place_name = items.getElementsByTagName( 'value')[0].firstChild.data #description logger.info('Place Name: %s Place Id: %s ' % (place_name, place_id)) import_data.address.locality_id = place_id logger.info('Locality Id: %s ' % import_data.address.locality_id) locality_add = self.process_locality( place_name, place_id, constants.PLACES_API_KEY) #if import_data.address.latlong == '': #locality = self.importDao.query_by_place_id(place_id) #import_data.address.latlong = locality.latlong #logger.info('Geo Location New: %s ' % import_data.address.latlong) else: logger.error('Error: %s' % auto_status) logger.debug('Populated File Data ' + str(import_data)) business_key = self.create_or_update_business( alias_name, import_data) import_data.business_id = business_key if entity_type == 'ground': ground = self.playgroundDao.query_by_alias(alias_name) if ground is not None: self.playgroundDao.copy_playground_model( ground, import_data) key = self.playgroundDao.persist( ground, self.user_info) upload_count += 1 logger.info( 'Playground updated for %s with key %s' % (alias_name, key)) else: key = self.playgroundDao.persist( import_data, self.user_info) upload_count += 1 logger.info('New playground created for %s' % (update['name'])) elif entity_type == 'club': tc = self.trainingCentreDao.query_by_alias(alias_name) if tc is not None: self.trainingCentreDao.copy_trainingCentre_model( tc, import_data) key = self.trainingCentreDao.persist( tc, self.user_info) upload_count += 1 logger.info( 'TrainingCentre updated for %s with key %s' % (alias_name, key)) else: key = self.trainingCentreDao.persist( import_data, self.user_info) upload_count += 1 logger.info('New training centre created for %s' % (update['name'])) elif entity_type == 'event': event = self.eventDao.query_by_alias(alias_name) if event is not None: self.eventDao.copy_event_model(event, import_data) key = self.eventDao.persist(event, self.user_info) upload_count += 1 logger.info('Event updated for %s with key %s' % (alias_name, key)) else: key = self.eventDao.persist( import_data, self.user_info) upload_count += 1 logger.info('Event created for %s' % (update['name'])) if key is not None: logger.info( str(entity_type) + ' succesfully created/updated') else: logger.error('Already Exist of %s:%s' % (entity_type, update['name'])) except StandardError as e: #skipping to next record logger.error('Error occured, %s, for %s' % (str(e), alias_name)) else: logger.info("skipping record number, %s " % row_count) return upload_count @webapp2.cached_property def form(self): return forms.ImportForm(self) def upload_photos(self, photos): upload_files = self.get_uploads() if upload_files is not None and len(upload_files) > 0: files_count = len(upload_files) logger.info('no of files uploaded ' + str(files_count)) for x in xrange(files_count): blob_info = upload_files[x] media_obj = Media() media_obj.name = self.form.media.__getitem__(x).data['name'] media_obj.status = self.form.media.__getitem__( x).data['status'] media_obj.link = blob_info.key() photos.append(media_obj) logger.info('Link to picture file ' + media_obj.name + ', ' + images.get_serving_url(media_obj.link)) return photos def create_or_update_business(self, alias_name, import_data): business = self.businessDao.query_by_alias(alias_name) if business is not None: business_key = business.key import_data.business_id = business_key logger.info('Business Already Exist with Key %s' % str(business_key)) else: try: business = Business() business.name = import_data.name business.description = import_data.description business.alias = import_data.alias business.contact_info = import_data.contact_info business_key = self.businessDao.persist( business, self.user_info) import_data.business_id = business_key logger.info('New Business Created for %s with key %s' % (alias_name, str(business_key))) except StandardError as e: #Skip the error and continue logger.error('Error occured, %s, for %s' % (str(e), alias_name)) raise return business_key def form_to_dao_ground(self, alias_name, **update): try: playground = Playground() playground.name = update['name'] #Create an automatic alias for the playground playground.alias = alias_name playground.description = update['description'] playground.sport = update['sport'] playground = self.form_to_dao_address_import(playground, **update) playground = self.form_to_dao_contact_info_import( playground, **update) #if playground.photos is None: #playground.photos = [] #self.upload_photos(playground.photos) except StandardError as e: logger.error('Error occured, %s, for %s:%s' % (str(e), type, update['name'])) raise return playground def form_to_dao_center(self, alias_name, **update): try: trainingcentre = TrainingCentre() trainingcentre.name = update['name'] #Create an automatic alias for the trainingcentre trainingcentre.alias = alias_name trainingcentre.description = update['description'] trainingcentre.sport = update['sport'] trainingcentre = self.form_to_dao_address_import( trainingcentre, **update) trainingcentre = self.form_to_dao_contact_info_import( trainingcentre, **update) #if trainingcentre.photos is None: #trainingcentre.photos = [] #self.upload_photos(trainingcentre.photos) except StandardError as e: logger.error('Error occured, %s, for %s:%s' % (str(e), type, update['name'])) raise return trainingcentre def form_to_dao_event(self, alias_name, **update): try: event = Event() event.name = update['name'] #Create an automatic alias for the event event.alias = alias_name event.description = update['description'] event.sport = update['sport'] #event.start_datetime = update['start_datetime'] #event.end_datetime = update['end_datetime'] event = self.form_to_dao_contact_info_import(event, **update) #if event.photos is None: #event.photos = [] #self.upload_photos(event.photos) except StandardError as e: logger.error('Error occured, %s, for %s:%s' % (str(e), type, update['name'])) raise return event def form_to_dao_business(self, **update): business = Business() business.name = update['name'] #Create an automatic alias for the business business.alias = utils.slugify(update['name']) business.description = update['description'] business = self.form_to_dao_contact_info_import(business, **update) return business def form_to_dao_address_import(self, entity, **update): #entity = playground try: if update['locality'] == '' or update['city'] == '': raise StandardError('Locality is empty. Cannot create entity') entity.address = Address() entity.address.line1 = update['line1'].lower() entity.address.line2 = update['line2'].lower() entity.address.locality = update['locality'].lower() entity.address.city = update['city'].lower() entity.address.pin = update['pin'] lattitude, longitude = get_latlong_from_address(entity.address) if lattitude is not None and longitude is not None: entity.address.latlong = ndb.GeoPt(lattitude, longitude) except StandardError as e: logger.error('Error occured, %s, for %s:%s' % (str(e), type, update['name'])) raise return entity def form_to_dao_contact_info_import(self, entity, **update): try: entity.contact_info = ContactInfo() if len(update['person_name']) > 0: entity.contact_info.person_name = [ x.strip() for x in update['person_name'].split(',') ] if len(update['email']) > 0: entity.contact_info.email = [ x.strip() for x in update['email'].split(',') ] if len(update['phone']) > 0: entity.contact_info.phone = [ x.strip() for x in update['phone'].split(',') ] entity.contact_info.website = update['website'] entity.contact_info.facebook = update['facebook'] entity.contact_info.twitter = update['twitter'] entity.contact_info.youtube = update['youtube'] entity.contact_info.gplus = update['gplus'] except StandardError as e: logger.error('Error occured, %s, for %s:%s' % (str(e), type, update['name'])) raise return entity