def write_to_db(self, user, tag, publication, actual_days_range=100):
db_user, db_user_created = get_or_create(self.db_session,
User,
instagram_pk=user['pk'])
if db_user_created or db_user.last_modified==None \
or (self.today - db_user.last_modified.date() > datetime.timedelta(days=actual_days_range)):
db_user.username = user['username']
db_user.full_name = user['full_name']
db_user.followers = get_browser_followers(user['username'])
print('Создание/Обновление пользователя: %s %s %s\n' %
(db_user.username, db_user.full_name, db_user.followers))
db_publication, db_publication_created = get_or_create(
self.db_session, Publication, instagram_pk=publication['pk'])
if db_publication_created:
db_publication.user_id = db_user.id
if db_publication.last_modified==None \
or (self.today - db_publication.last_modified.date() > datetime.timedelta(days=actual_days_range)):
db_publication.like_count = publication['like_count']
db_publication.link_code = publication['code']
db_publication.device_timestamp = datetime.datetime.fromtimestamp(
int(str(publication['device_timestamp'])[:10]))
print('Создание/Обновление публикации: %s %s %s\n' %
(db_publication.link_code, db_user.full_name,
db_publication.like_count))
db_tag, db_tag_created = get_or_create(self.db_session, Tag, name=tag)
if db_tag_created:
db_tag.publications.append(db_publication)
print('Создание тега: %s' % tag)
self.db_session.commit()
def get_or_create_transaction(message):
defaults = make_transaction_defaults(message)
transaction, is_created = get_or_create(session,
Transaction,
defaults=defaults,
uuid=message["transaction_id"])
return transaction, is_created
def create_task(session, task_name, tag_names=[], project_name=None):
"""
Args: session:sqlalchemy session object
task_name:string
tag_names:list of strings
project_name:string
Returns: task object
"""
task = Tasks(task_name)
if tag_names:
for tag_name in tag_names:
tag = get_or_create(session, Tags, tag_name)
assert tag != None
task.tags.append(tag)
if project_name:
project = get_or_create(session, Projects, project_name)
task.project = project
return task
def create_task(session, task_name, tag_names=[], project_name=None):
"""
Args: session:sqlalchemy session object
task_name:string
tag_names:list of strings
project_name:string
Returns: task object
"""
task = Tasks(task_name)
if tag_names:
for tag_name in tag_names:
tag = get_or_create(session, Tags, tag_name)
assert tag != None
task.tags.append(tag)
if project_name:
project = get_or_create(session, Projects, project_name)
task.project = project
return task
def process_raw_message(raw_message):
message = get_message_from_raw(raw_message)
try:
transaction, is_created = get_or_create_transaction(message)
except InvalidTransactionMessage:
return
if not is_created:
# We don't care about what status is the existing transaction is in.
# It is a problem if it already exists.
logger.error("Transaction <%s> already exists, skipping",
transaction.uuid)
return
storage, is_created = get_or_create(session,
Storage,
store_id=transaction.store_id,
item_id=transaction.item_id,
defaults={"stock": 0})
process_transaction(transaction, storage)
session.commit()
def update(session_id=None):
""" Sync backbone model with appropriate database. """
current_app.logger.info("PUT /sync route with id: %s" % session_id)
resp = None
try:
session = Session.query.filter_by(session_id=session_id).one()
except SQLAlchemyError:
resp = {"status": "bad request"}
current_app.logger.error("DB error: Unique user not found.")
# Check JSON validity
if utils.check_valid_json(request.get_data()):
valid_json = json.loads(request.get_data())
else:
resp = {"status": "bad request"}
current_app.logger.error("Invalid JSON")
current_app.logger.info(
"Current trial: %s, session id: %s " %
(valid_json['currenttrial'], valid_json['sessionid']))
# For each trial, pass to appropriate parser, if not in db
for json_trial in valid_json['data']:
if session.exp_name == "category_switch":
experiment_class = CategorySwitch
elif session.exp_name == "keep_track":
experiment_class = KeepTrack
db_trial, new = db_utils.get_or_create(
db.session,
experiment_class,
token=session.token,
session_id=session.session_id,
trial_num=json_trial['current_trial'])
# If the trial is new, add data
if new:
db_trial.add_json_data(json_trial)
db.session.commit()
# For each event, pass to parser, if not in db
for json_event in valid_json['eventdata']:
db_event, new = db_utils.get_or_create(
db.session,
EventData,
token=session.token,
session_id=session.session_id,
exp_name=session.exp_name,
timestamp=utils.convert_timestamp(json_event['timestamp']))
if new:
db_event.add_json_data(json_event)
db.session.commit()
if valid_json['questiondata'] != {}:
# For the QuestionData, pass to parser, if not in db
db_ques, new = db_utils.get_or_create(db.session,
QuestionData,
token=session.token,
session_id=session.session_id,
exp_name=session.exp_name)
db_ques.add_json_data(valid_json['questiondata'])
db.session.commit()
if resp is None:
resp = {"status": "success"}
return jsonify(**resp)
def start_exp():
""" Serves up the experiment applet.
If experiment is ongoing or completed, will not serve.
Querystring args (required):
uniqueid: External gfg_id
surveyid: Which experiment to serve
"""
browser, platform = utils.check_browser_platform(request.user_agent)
# Check query string
if not utils.check_qs(request.args, ['uniqueid', 'surveyid']):
raise ExperimentError('improper_inputs')
else:
uniqueid = request.args['uniqueid']
survey_id = request.args['surveyid']
exp_name = experiment_list[
request.args['surveyid']] # Survey id to experiment name
# Decrypt encocded uniqueid
gfg_id = utils.decrypt(str(current_app.config['SECRET_KEY']),
str(uniqueid).decode('string-escape'))
# Check if user exists in main gfg db
if not db_utils.gfg_user_exists(gfg_id,
current_app.config['RESEARCH_DB_HOST'],
current_app.config['RESEARCH_DB_USER'],
current_app.config['RESEARCH_DB_PASSWORD'],
current_app.config['RESEARCH_DB_NAME']):
raise ExperimentError('user_access_denied')
# Check if user is in Participant table, if not add & commit
user, new_user = db_utils.get_or_create(db.session,
Participant,
gfg_id=gfg_id)
current_app.logger.info(
"Subject: %s entered with %s platform and %s browser" %
(gfg_id, platform, browser))
# If any existing sessions disqualify user (ongoing or completed), throw error
# Otherwise, create new session and serve experiment
disqualifying_sessions = Session.query.filter_by(gfg_id=gfg_id,
exp_name=exp_name,
status=3).first()
if disqualifying_sessions and current_app.config['EXP_DEBUG'] == False:
raise ExperimentError('already_did_exp',
session_id=disqualifying_sessions.session_id)
# Otherwise, allow participant to re-enter
else:
session = Session(gfg_id=gfg_id,
browser=browser,
platform=platform,
status=1,
exp_name=exp_name,
begin_session=datetime.datetime.now())
db.session.add(session)
db.session.commit()
return render_template(exp_name + "/exp.html",
experimentname=exp_name,
surveyid=survey_id,
sessionid=session.session_id,
debug=current_app.config['EXP_DEBUG'],
uniqueid=urllib.quote(uniqueid))
def update(session_id=None):
""" Sync backbone model with appropriate database. """
current_app.logger.info("PUT /sync route with id: %s" % session_id)
resp = None
try:
session = Session.query.filter_by(session_id=session_id).one()
except SQLAlchemyError:
resp = {"status": "bad request"}
current_app.logger.error("DB error: Unique user not found.")
# Check JSON validity
if utils.check_valid_json(request.get_data()):
valid_json = json.loads(request.get_data())
else:
resp = {"status": "bad request"}
current_app.logger.error("Invalid JSON")
current_app.logger.info(
"Current trial: %s, session id: %s " %
(valid_json['currenttrial'], valid_json['sessionid']))
## JAKE: This needs to be slightly customized to add your task
## However, most of the work will be in models.py
# For each trial, pass to appropriate parser, if not in db
for json_trial in valid_json['data']:
if session.exp_name == "category_switch":
experiment_class = CategorySwitch
elif session.exp_name == "keep_track":
experiment_class = KeepTrack
elif session.exp_name == 'BART':
experiment_class = BART
db_trial, new = db_utils.get_or_create(
db.session,
experiment_class,
gfg_id=session.gfg_id,
session_id=session.session_id,
trial_num=json_trial['current_trial'])
# If the trial is new, add data
if new:
db_trial.add_json_data(json_trial)
db.session.commit()
## JAKE: this part is for recording events that dataHandler (i.e. psiTurk),
## tracks, automatically
# For each event, pass to parser, if not in db
for json_event in valid_json['eventdata']:
db_event, new = db_utils.get_or_create(
db.session,
EventData,
gfg_id=session.gfg_id,
session_id=session.session_id,
exp_name=session.exp_name,
timestamp=utils.convert_timestamp(json_event['timestamp']))
if new:
db_event.add_json_data(json_event)
db.session.commit()
## JAKE: Don't worry about this now, you won't have any question data
if valid_json['questiondata'] != {}:
# For the QuestionData, pass to parser, if not in db
db_ques, new = db_utils.get_or_create(db.session,
QuestionData,
gfg_id=session.gfg_id,
session_id=session.session_id,
exp_name=session.exp_name)
db_ques.add_json_data(valid_json['questiondata'])
db.session.commit()
if resp is None:
resp = {"status": "success"}
return jsonify(**resp)