def addDiagnoseComment():
form = CommentsForm(request.form)
resultForm=form.validate()
if resultForm.status==rs.SUCCESS.status:
#session['remember_me'] = form.remember_me.data
# login and validate the user...
diagnoseComment=Comment(form.userId,form.receiverId,form.diagnoseId,form.content)
db_session.add(diagnoseComment)
db_session.commit()
db_session.flush()
score=constant.DiagnoseScore[form.score]
diagnose=Diagnose.getDiagnoseById(form.diagnoseId)
diagnose.score=form.score
Diagnose.save(diagnose)
#为医生添加一些冗余字段
if hasattr(diagnose,'doctor'):
doctor=diagnose.doctor
if score!=0:
if doctor.goodFeedbackCount:
doctor.goodFeedbackCount+=1
else:
doctor.goodFeedbackCount=1
if doctor.feedbackCount:
doctor.feedbackCount+=1
else:
doctor.feedbackCount=1
Doctor.save(doctor)
#flash('成功添加诊断评论')
return jsonify(rs.SUCCESS.__dict__)
return jsonify(rs.FAILURE.__dict__)
def upload_file(board, post_id=None):
# Create the post
post = models.Post(subject=request.form.get('subject'),
comment=request.form.get('comment'),
parent_id=post_id)
db_session.add(post)
db_session.flush()
# Upload the file if present
f = request.files['file']
if f.filename:
extension = get_extension(f)
filename = "{0}.{1}".format(post.generate_filename(), extension)
path = "{0}/static/{1}".format(app.root_path, filename)
f.save(path)
post.filename = filename
post.mimetype = f.mimetype
db_session.commit()
# Redirect to page or post
if post_id:
return redirect(url_for('reply', board=board, post_id=post_id))
else:
return redirect(url_for('page', board=board))
def save(self, doctorProfile):
if doctorProfile:
if doctorProfile.createTime is None:
doctorProfile.createTime = datetime.now()
session.add(doctorProfile)
session.commit()
session.flush()
def test_addAllRole(self):
from DoctorSpring.models.user import Role,UserRole
role=Role()
role.id=1
role.roleName='fenzhen'
session.add(role)
role=Role()
role.id=2
role.roleName='doctor'
session.add(role)
role=Role()
role.id=3
role.roleName='patient'
session.add(role)
role=Role()
role.id=4
role.roleName='hospitalUser'
session.add(role)
role=Role()
role.id=6
role.roleName='kefu'
session.add(role)
session.commit()
session.flush()
def upload_file(board, post_id=None):
# Create the post
post = models.Post(subject=request.form.get('subject'),
comment=request.form.get('comment'),
parent_id=post_id)
db_session.add(post)
db_session.flush()
# Upload the file if present
f = request.files['file']
if f.filename:
extension = get_extension(f)
filename = "{0}.{1}".format(post.generate_filename(), extension)
path = "{0}/static/{1}".format(app.root_path, filename)
f.save(path)
post.filename = filename
post.mimetype = f.mimetype
db_session.commit()
# Redirect to page or post
if post_id:
return redirect(url_for('reply', board=board, post_id=post_id))
else:
return redirect(url_for('page', board=board))
def edit_task(task_id):
task = Task.query.get(task_id)
if not task:
return jsonify(dict())
if task.user_id != current_user.id:
return jsonify(dict())
task.description = request.form['description']
task.notes = request.form['notes']
if request.form['complete'] == 'true':
task.complete = True
else:
task.complete = False
task.latitude = request.form['latitude']
task.longitude = request.form['longitude']
category_name = request.form['category']
if category_name == '':
category_name = 'Default'
category = Category.query.filter(Category.name == category_name).first()
if not category:
category = Category(name=category_name)
db_session.add(category)
db_session.flush()
category_id = category.id
task.category_id = category_id
#task.attachment = request.form['attachment']
if request.form['due_date'] == '':
due_date = None
else:
due_date = datetime.strptime(request.form['due_date'], "%m/%d/%Y")
db_session.commit()
return jsonify(task.info())
def changeDiagnoseStatus(cls,diagnoseId,status):
if diagnoseId and status:
diagnose=Diagnose.getDiagnoseById(diagnoseId)
if diagnose:
diagnose.status=status
session.commit()
session.flush()
def update(cls,userId,name=None,account=None,mobile=None,address=None,email=None,identityCode=None,yibaoCard=None,passwd=None,isBindPhone=None,imagePath=None,status=None):
if userId is None or userId<1:
return
user=session.query(User).filter(User.id==userId).first()
if user:
if name:
user.name=name
if account:
user.account=account
if address:
user.address=address
if mobile:
user.phone=mobile
if email:
user.email=email
if identityCode:
user.identityCode=identityCode
if yibaoCard:
user.yibaoCard=yibaoCard
if passwd:
user.password=passwd
if isBindPhone:
user.isBindPhone= isBindPhone
if imagePath:
user.imagePath=imagePath
if status or status==0:
user.status=status
session.commit()
session.flush()
return user
def update(cls, doctor):
if doctor is None or doctor.userId is None:
return
doctorNeedChange = session.query(Doctor).filter(
Doctor.userId == doctor.userId,
Doctor.status == ModelStatus.Draft).first()
if doctorNeedChange is None:
return
if doctor.status:
doctorNeedChange.status = doctor.status
if doctor.username:
doctorNeedChange.username = doctor.username
if doctor.identityPhone:
doctorNeedChange.identityPhone = doctor.identityPhone
# if doctor.status:
# doctorNeedChange.status=doctor.status
if doctor.title:
doctorNeedChange.title = doctor.title
if doctor.departmentId:
doctorNeedChange.departmentId = doctor.departmentId
if doctor.hospitalId:
doctorNeedChange.hospitalId = doctor.hospitalId
session.commit()
session.flush()
return doctorNeedChange.hospitalId
def addDiagnoseComment():
form = CommentsForm(request.form)
resultForm = form.validate()
if resultForm.status == rs.SUCCESS.status:
#session['remember_me'] = form.remember_me.data
# login and validate the user...
diagnoseComment = Comment(form.userId, form.receiverId,
form.diagnoseId, form.content)
db_session.add(diagnoseComment)
db_session.commit()
db_session.flush()
score = constant.DiagnoseScore[form.score]
diagnose = Diagnose.getDiagnoseById(form.diagnoseId)
diagnose.score = form.score
Diagnose.save(diagnose)
#为医生添加一些冗余字段
if hasattr(diagnose, 'doctor'):
doctor = diagnose.doctor
if score != 0:
if doctor.goodFeedbackCount:
doctor.goodFeedbackCount += 1
else:
doctor.goodFeedbackCount = 1
if doctor.feedbackCount:
doctor.feedbackCount += 1
else:
doctor.feedbackCount = 1
Doctor.save(doctor)
#flash('成功添加诊断评论')
return jsonify(rs.SUCCESS.__dict__)
return jsonify(rs.FAILURE.__dict__)
def create_patient(data):
if 'given_name' not in data or 'family_name' not in data:
return None
person = Person(gender=data.get('gender', None))
person_name = PersonName(person=person,
given_name = data.get('given_name', None),
middle_name = data.get('middle_name', None),
family_name = data.get('family_name', None),
uuid = str(uuid.uuid4()))
person_address = PersonAddress(person=person,
address1 = data.get('address1', None),
address2 = data.get('address2', None),
city_village = data.get('city', None),
state_province = data.get('province', None),
country = data.get('country', None),
postal_code = data.get('postal_code', None))
db_session.add(person)
db_session.add(person_name)
db_session.add(person_address)
db_session.flush()
patient = Patient(person=person)
patient_identifier = PatientIdentifier(patient=patient,
identifier_type = 2,
identifier = '{}_{}_{}'.format(person.person_id,
data.get('given_name',''),
data.get('family_name','')))
db_session.add(patient)
db_session.add(patient_identifier)
db_session.commit()
return patient.patient_id
def deleteByPathologyId(cls,pathologyId):
if pathologyId:
pathologyPostions = session.query(PathologyPostion).filter(PathologyPostion.pathologyId == pathologyId).all()
for position in pathologyPostions:
session.delete(position)
session.commit()
session.flush()
def save(self, doctorProfile):
if doctorProfile:
if doctorProfile.createTime is None:
doctorProfile.createTime = datetime.now()
session.add(doctorProfile)
session.commit()
session.flush()
def test_create_article():
_author_id = random.randint(1, 20)
_new_article = Article()
_new_article.title = 'Test_Article_%s' % random.randint(100001, 999999)
_new_article.author_id = _author_id
_new_article.published_datetime = _new_article.last_modified_datetime = datetime.datetime.now()
_random_seed = str(random.random())
_new_article.digest = 'digest - %s' % (''.join(random.randint(2, 5)*md5(_random_seed).hexdigest()))
_content = ArticleContent(content='content - %s' % (''.join(random.randint(10, 50)*sha224(_random_seed).hexdigest())))
_new_article.content = _content
db_session.add(_new_article) # @UndefinedVariable
db_session.flush() # @UndefinedVariable
_catalogs = [
random.randint(1, 20),
random.randint(1, 20),
random.randint(1, 20),
]
for _cid in _catalogs:
db_session.execute(association_table_catalog_article.insert().values({ # @UndefinedVariable
'catalog_id': _cid,
'article_id': _new_article.id,
}))
db_session.commit() # @UndefinedVariable
def push_to_sql(data, batch_id, category):
def parse_data(d):
# iterate over the key/values pairings
for k, v in d.items():
if v == u'Wahiaw\xe4, HI':
d[k] = u'Wahiawa, HI'
if isinstance(v, str):
d[k] = ''.join([i if ord(i) < 128 else ' ' for i in text])
return d
for i, d in enumerate(data):
d = parse_data(d)
j = JobsData()
j.batch_id = batch_id
j.category_id = category
j.numJobs = d['numJobs']
j.name = d['name']
j.stateAbbreviation = d['stateAbbreviation']
j.stateName = d['stateName']
j.id = d['id']
j.latitude = d['latitude']
j.longitude = d['longitude']
db_session.add(j)
if i % 1000 == 0:
db_session.flush()
db_session.commit()
return
def update_live_locations():
# Delete existing data from vehicles
Vehicle.query.delete()
# Get live vehicles as json data
json_data = requests.get(API_VEHICLES, headers=API_HEADER)
vehicle_dict = json.loads(json_data.text)
# Array of service objects
vehicles = vehicle_dict["vehicles"]
# Update the vehicle table's last_updated field
vehicles_date = datetime.fromtimestamp(int(vehicle_dict["last_updated"]))
update_table_date("vehicle", vehicles_date)
# Create a vehicle instance of each vehicle.
for vehicle in vehicles:
new_vehicle = Vehicle()
new_vehicle.vehicle_id = vehicle["vehicle_id"]
new_vehicle.destination = vehicle["destination"]
new_vehicle.speed = vehicle["speed"]
new_vehicle.heading = vehicle["heading"]
new_vehicle.latitude = vehicle["latitude"]
new_vehicle.longitude = vehicle["longitude"]
new_vehicle.service_name = vehicle["service_name"]
db_session.add(new_vehicle)
db_session.commit()
db_session.flush()
def push_to_sql(data, batch_id, category):
def parse_data(d):
# iterate over the key/values pairings
for k, v in d.items():
if v == u'Wahiaw\xe4, HI':
d[k] = u'Wahiawa, HI'
if isinstance(v, str):
d[k] = ''.join([i if ord(i) < 128 else ' ' for i in text])
return d
for i, d in enumerate(data):
d = parse_data(d)
j = JobsData()
j.batch_id = batch_id
j.category_id = category
j.numJobs = d['numJobs']
j.name = d['name']
j.stateAbbreviation = d['stateAbbreviation']
j.stateName = d['stateName']
j.id = d['id']
j.latitude = d['latitude']
j.longitude = d['longitude']
db_session.add(j)
if i % 1000 == 0:
db_session.flush()
db_session.commit()
return
def setDiagnoseUploaded(cls,diagnoseId):
if diagnoseId :
diagnose=session.query(Diagnose).filter(Diagnose.id==diagnoseId,Diagnose.status!=DiagnoseStatus.Del).first()
if diagnose:
diagnose.ossUploaded=constant.DiagnoseUploaed.Uploaded
session.commit()
session.flush()
def add(data):
try:
db_session.add(data)
db_session.commit()
return True, data
except Exception as e:
db_session.flush()
return False, e
def add(data):
try:
db_session.add(data)
db_session.commit()
return data
except:
db_session.flush()
return False
def _get_posts(s, batch, county_id, n, p):
url = 'http://api.arbetsformedlingen.se/af/v0/platsannonser/matchning?lanid=%s&antalrader=%s&sida=%s' % (county_id, n, p)
response = s.get(url=url)
try:
obj = json.loads(response.text)
for index, item in enumerate(obj["matchningslista"]["matchningdata"]):
try:
post = Post.query.filter_by(external_id=str(item["annonsid"])).first()
if post:
app.logger.info('Post %s already exists, adding to new batch.' % post.external_id)
else:
post = Post()
post.external_id = str(item["annonsid"])
post.published = parse(item["publiceraddatum"])
# profession is mandatory
post.profession = Profession.query.filter_by(name=item["yrkesbenamning"]).one()
if "antalplatser" in item:
try:
post.num_jobs = int(item["antalplatser"])
except ValueError:
app.logger.warning('Could not parse number of jobs for %s' % post.external_id)
# municipality is optional
try:
post.municipality = Municipality.query.filter_by(id=int(item["kommunkod"])).one()
except (NoResultFound, KeyError):
app.logger.warning('No municipality match "%s", post annonsid=%s, saving with unspecified.' % (item["kommunkod"], post.external_id))
post.municipality = Municipality.query.filter_by(id="Ospecifierad arbetsort").one()
post.match_data = item
db_session.add(post)
post.batches.append(batch)
db_session.commit()
db_session.flush()
except KeyError as e:
app.logger.error('Attribute "%s" missing from dict. Aborting.' % e)
app.logger.debug(json.dumps(item, indent=4))
except IntegrityError:
app.logger.warning('Post already exists for %s' % item["annonsid"])
db_session.rollback()
except ValueError as e:
app.logger.error(e)
app.logger.debug(json.dumps(item, indent=4))
except NoResultFound as e:
app.logger.error('Could not find match for %s. Aborting.' % item["annonsid"])
app.logger.debug(e)
# fixme: this will abort parsing if server runs out of memory
pages = obj["matchningslista"]["antal_sidor"]
if p < pages:
app.logger.debug('Retrieving page %s of %s' % (p + 1, pages))
_get_posts(s, batch, county_id, n, p + 1)
except ValueError:
app.logger.error('Could not parse json response from API. Aborting.')
app.logger.debug(response.text)
def get_sleep_from_fitbit(user_name, dates):
try:
user = db_session.query(User).filter(User.user_name == user_name).first()
token = ast.literal_eval(user.fitbit_access_token)
# access_token = token['access_token']
refresh_token = token['refresh_token']
token = get_new_refresh_token('227PT7', '52d59408469ac8aa82d4bdcca69071a6', refresh_token)
if 'access_token' in token:
user.fitbit_access_token = str(token)
db_session.flush()
token = ast.literal_eval(token)
server = fitbit.Fitbit(client_id='227PT7', client_secret='52d59408469ac8aa82d4bdcca69071a6',
access_token=token['access_token'], refresh_token=token['refresh_token'])
sleep = []
for one_date in dates:
sleep_fitbit_objects = server.get_sleep(one_date)
if len(sleep_fitbit_objects['sleep']) > 0:
i = 0
for sleep_fitbit_object in sleep_fitbit_objects['sleep']:
sleep_db_object = db_session.query(Sleep).filter(
Sleep.log_id == str(sleep_fitbit_object['logId'])).first()
if sleep_db_object is None:
sleep_object = Sleep()
sleep_object.log_id = str(sleep_fitbit_object['logId'])
sleep_object.awake_count = sleep_fitbit_object['awakeCount']
sleep_object.awake_duration = sleep_fitbit_object['awakeDuration']
sleep_object.date_of_sleep = sleep_fitbit_object['dateOfSleep']
sleep_object.duration = sleep_fitbit_object['duration']
sleep_object.efficiency = sleep_fitbit_object['efficiency']
sleep_object.is_main_sleep = sleep_fitbit_object['isMainSleep']
sleep_object.minutes_after_wakeup = sleep_fitbit_object['minutesAfterWakeup']
sleep_object.minutes_awake = sleep_fitbit_object['minutesAwake']
sleep_object.minutes_asleep = sleep_fitbit_object['minutesAsleep']
sleep_object.restless_count = sleep_fitbit_object['restlessCount']
sleep_object.restless_duration = sleep_fitbit_object['restlessDuration']
sleep_object.start_time = sleep_fitbit_object['startTime']
sleep_object.time_in_bed = sleep_fitbit_object['timeInBed']
sleep_object.minute_data = str(sleep_fitbit_object['minuteData'])
sleep_object.user_id = user.id
sleep_object.minutes_to_fall_asleep = sleep_fitbit_object['minutesToFallAsleep']
db_session.add(sleep_object)
db_session.flush()
i += 1
sleep.append(sleep_fitbit_object)
return sleep
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def save(cls,consult):
if consult:
session.add(consult)
if consult.source_id!=None and consult.source_id!=-1:
source=Consult.getById(consult.source_id)
source.updateTime=datetime.now()
session.commit()
session.flush()
def save(cls, diagnose):
if diagnose:
session.add(diagnose)
session.commit()
if diagnose.id:
diagnoseSeriesNumber='%s%i'%(constant.DiagnoseSeriesNumberPrefix,constant.DiagnoseSeriesNumberBase+diagnose.id)
diagnose.diagnoseSeriesNumber=diagnoseSeriesNumber
session.commit()
session.flush()
def change_user_password(userId, password):
try:
user = User.query.filter(User.id == userId).one()
user.password = password
db_session.commit()
return True
except:
db_session.flush()
return False
def save(cls, consult):
if consult:
session.add(consult)
if consult.source_id != None and consult.source_id != -1:
source = Consult.getById(consult.source_id)
source.updateTime = datetime.now()
session.commit()
session.flush()
def delete_services_stops():
# Delete existing data from stops, services and their linking table
Service.query.delete()
Stop.query.delete()
StopService.query.delete()
db_session.commit()
db_session.flush()
def start():
request_data: dict = request_to_json(request)
conf: Artifact = setup_workdir(request_data)
db_session.begin()
db_session.flush()
step = db_session.query(SimulationStep).get(conf.step_id)
task = run_simulation.delay(conf.id)
step.celery_id = task.id
db_session.commit()
return jsonify(step)
def delete_user_by_id(userId):
try:
user = User.query.filter(User.id == userId).one()
delete_session_by_user(user.id)
db_session.delete(user)
db_session.commit()
return True
except:
db_session.flush()
return False
def update(cls,consult):
if consult is None or consult.id is None:
return
consultNeedChange=session.query(Consult).filter(Consult.id==consult.id,Consult.status==ModelStatus.Normal).first()
if consultNeedChange is None:
return
if consult.count:
consultNeedChange.count=consult.count
session.commit()
session.flush()
def update_table_date(table_name, new_date):
if is_table_filled(table_name):
service_update = Update.query.filter_by(table_name=table_name).first()
service_update.last_updated = new_date
else:
service_update = Update()
service_update.table_name = table_name
service_update.last_updated = new_date
db_session.add(service_update)
db_session.commit()
db_session.flush()
def updateHospital(hospital):
if hospital is None or hospital.id is None:
return
hospitalNeedChange=session.query(Hospital).filter(Hospital.id==hospital.id,Hospital.status==constant.ModelStatus.Normal).first()
if hospitalNeedChange is None:
return
if hospital.name:
hospitalNeedChange.name=hospital.name
if hospital.address:
hospitalNeedChange.address=hospital.address
session.commit()
session.flush()
def update_services_stops():
# Delete all data first
delete_services_stops()
# Get services as json data
json_data = requests.get(API_SERVICES, headers=API_HEADER)
service_dict = json.loads(json_data.text)
# Array of service objects
services = service_dict["services"]
# Get stops as json data
json_data = requests.get(API_STOPS, headers=API_HEADER)
stop_dict = json.loads(json_data.text)
# Array of stop objects
stops = stop_dict["stops"]
# Update the tables' last_updated field
service_date = datetime.fromtimestamp(int(service_dict["last_updated"]))
update_table_date("service", service_date)
stop_date = datetime.fromtimestamp(int(stop_dict["last_updated"]))
update_table_date("stop", stop_date)
# Create a service instance of each service and store them in a new dictionary
service_dict = {}
for service in services:
new_service = Service()
new_service.name = service["name"]
new_service.service_type = service["service_type"]
new_service.description = service["description"]
new_service.route = json.dumps(service["routes"][0]["points"]) if len(service["routes"]) > 0 else "none"
service_dict[service["name"]] = new_service
db_session.add(new_service)
# Create a stop instance of each stop and add corresponding services to them
for stop in stops:
new_stop = Stop()
new_stop.name = stop["name"]
new_stop.latitude = stop["latitude"]
new_stop.longitude = stop["longitude"]
# Add services to stops
# Must take the set because sometimes the services are listed multiple times for a particular stop.
stop_services = set(stop["services"])
for service_name in stop_services:
new_stop.services.append(service_dict[service_name])
db_session.add(new_stop)
db_session.commit()
db_session.flush()
def insert_invalid_null(self):
new_vehicle = Vehicle()
new_vehicle.vehicle_id = None # Should not be null, so we expect and exception
new_vehicle.service_name = "test"
new_vehicle.destination = "test"
new_vehicle.heading = 50
new_vehicle.latitude = 4.00
new_vehicle.longitude = 5.00
new_vehicle.speed = 40
db_session.add(new_vehicle)
db_session.commit()
db_session.flush()
def delete_food(user_name, food_id):
try:
user = db_session.query(User).filter(User.user_name == user_name).first()
food = db_session.query(Food).filter(Food.id == food_id).filter(Food.user_id == user.id).one()
db_session.delete(food)
db_session.flush()
return {"message": "Success"}
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def log_food(user_name, food_type, title, timestamp, score, picture, grams):
try:
user = db_session.query(User).filter(User.user_name == user_name.lower()).first()
food = Food(user.id, food_type.lower(), title, timestamp, score, str(picture), grams)
db_session.add(food)
db_session.flush()
return {"message": "Success", "food": food.get_dict()}
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def delete_activity(user_name, activity_id):
try:
user = db_session.query(User).filter(User.user_name == user_name).first()
activity = db_session.query(Activity).filter(Activity.id == activity_id).filter(Activity.user_id == user.id).one()
db_session.delete(activity)
db_session.flush()
return {"message": "Success"}
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def update(cls,reportDiagnoseRelationId,status=None):
if reportDiagnoseRelationId is None:
return
reportDiagnoseRelation = session.query(ReportDiagnoseRelation).filter(ReportDiagnoseRelation.id==reportDiagnoseRelationId).first()
if reportDiagnoseRelation:
if status or status==0:
reportDiagnoseRelation.status=status
session.flush()
session.commit()
return reportDiagnoseRelation
def log_activity(user_name, activity_type, start_time, end_time):
try:
user = db_session.query(User).filter(User.user_name == user_name).first()
print user.id
activity = Activity(user.id, activity_type, start_time, end_time)
db_session.add(activity)
db_session.flush()
return {"message": "Success", "activity": activity.get_dict()}
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def insertOrUpdate(Id, first_name, last_name, email):
exists = db_session.query(exists().where(Student.id == Id)).scalar()
if exists:
student = Student.query.filter_by(Id=id).first()
student.first_name = first_name
student.last_name = last_name
db_session.commit()
new_student = Student(first_name=first_name, last_name=last_name)
db_session.add(new_student)
db_session.flush()
return True
def push_to_sql(data, code, batch_id):
print "push_to_sql: %s" % code
for i, d in data.iterrows():
h = HomeValue()
h.batch_id = batch_id
h.city_code = code
h.valuation_date = d['Date']
h.median_value = d['Value']
db_session.add(h)
if i % 1000 == 0:
db_session.flush()
db_session.commit()
return
def test_stop_has_services(self):
new_stop = self.make_random_stop()
new_service = self.make_random_service()
new_stop.services.append(new_service)
db_session.add(new_stop)
db_session.add(new_service)
db_session.commit()
db_session.flush()
stop = Stop.query.all()[0]
self.assertEquals(len(stop.services), 1)
def update(cls,doctor):
if doctor is None or doctor.userId is None:
return
doctorNeedChange=session.query(Doctor).filter(Doctor.userId==doctor.userId,Doctor.status==ModelStatus.Normal).first()
if doctorNeedChange is None:
return
if doctor.username:
doctorNeedChange.username=doctor.username
if doctor.identityPhone:
doctorNeedChange.identityPhone=doctor.identityPhone
session.commit()
session.flush()
return doctorNeedChange.hospitalId
def updateHospital(hospital):
if hospital is None or hospital.id is None:
return
hospitalNeedChange = session.query(Hospital).filter(
Hospital.id == hospital.id,
Hospital.status == constant.ModelStatus.Normal).first()
if hospitalNeedChange is None:
return
if hospital.name:
hospitalNeedChange.name = hospital.name
if hospital.address:
hospitalNeedChange.address = hospital.address
session.commit()
session.flush()
def newsletter():
if request.method == "POST":
newsletter = Newsletter(
header_text=request.form['header_text'],
banner_1_active='banner_1_active' in request.form,
banner_1_url=request.form['banner_1_url'],
banner_1_image=request.form['banner_1_image'],
banner_2_active='banner_2_active' in request.form,
banner_2_url=request.form['banner_2_url'],
banner_2_image=request.form['banner_2_image'],
banner_3_active='banner_3_active' in request.form,
banner_3_url=request.form['banner_3_url'],
banner_3_image=request.form['banner_3_image'],
banner_4_active='banner_4_active' in request.form,
banner_4_url=request.form['banner_4_url'],
banner_4_image=request.form['banner_4_image'],
type_link=request.form['type_link'],
id_affil=request.form['id_affil'],
template=request.form['template'],
date_from=datetime.strptime(request.form['date_from'].strip(),
"%d/%m/%Y")
if "/" in request.form['date_from'] else request.form['date_from'],
date_to=datetime.strptime(request.form['date_to'].strip(),
"%d/%m/%Y")
if "/" in request.form['date_to'] else request.form['date_to'])
db_session.add(newsletter)
db_session.flush()
for cat in request.form['categories'].split(","):
n_c = NewsletterCategory(id_newsletter=newsletter.id_newsletter,
category=cat.strip())
db_session.add(n_c)
db_session.flush()
for i in xrange(0, 5):
try:
return render_template(
'newsletter.html',
newsletters=Newsletter.query.order_by(
"id_newsletter DESC").limit(50).all(),
categories=[
unicode(str(c), "latin-1")
for c in Category.query.order_by("category").all()
])
except OperationalError:
#retry
pass
time.sleep(i)
raise Exception("Mysql has gone away")
def addSession(token, user_id):
user = db_session.query(User).filter(User.id == user_id, User.status == 1)
if user.count() == 1:
session = Session(user_id, token, '0.0.0.0', '{"browser": "chrome"}')
try:
db_session.add(session)
db_session.commit()
return True
except Exception as e:
db_session.rollback()
db_session.flush()
return False
finally:
db_session.close()
def register(self, username, passwd):
if (len(username) == 0):
resp = {"message": "用户名不可为空", "successed": False}
return resp
#查证是否已存在
users = Users.query.filter(Users.username == username).first()
print users
if users != None: #没有找到用户名为给定值的元组
resp = {"message": "用户已存在，请重试", "successed": False}
return resp
#插入数据库
newuser = Users(username, passwd)
db_session.add(newuser)
db_session.flush()
return {"message": "注册成功！", "successed": True}
def update(cls,diagnose):
if diagnose is None or diagnose.id is None:
return
diagnoseNeedChange=session.query(Diagnose).filter(Diagnose.id==diagnose.id)
if diagnoseNeedChange is None:
return
if diagnose.status or diagnose.status==0:
diagnoseNeedChange.status=diagnose.status
if diagnose.ossUploaded or diagnose.ossUploaded==0:
diagnoseNeedChange.ossUploaded =diagnose.ossUploaded
if diagnose.supportStaffCall or diagnose.supportStaffCall==0:
diagnoseNeedChange.supportStaffCall=diagnose.supportStaffCall
if diagnose.uploadUserId :
diagnoseNeedChange.uploadUserId=diagnose.uploadUserId
session.commit()
session.flush()
def update(cls, consult):
if consult is None or consult.id is None:
return
consultNeedChange = session.query(Consult).filter(
Consult.id == consult.id,
Consult.status == ModelStatus.Normal).first()
if consultNeedChange is None:
return
if consult.count:
consultNeedChange.count = consult.count
if consult.status:
consultNeedChange.status = consult.status
session.commit()
session.flush()
def edit_activity(user_name, activity_id, activity_type, start_time, end_time):
try:
user = db_session.query(User).filter(User.user_name == user_name.lower()).first()
activity = db_session.query(Activity).filter(Activity.id == activity_id).filter(Activity.user_id == user.id).one()
activity.activity_type = activity_type
if end_time is not None:
activity.end_time = end_time
if start_time is not None:
activity.start_time = start_time
db_session.flush()
return {"message": "Success", "food": activity.get_dict()}
except Exception as e:
raise GenericError(e.message)
except:
raise GenericError("Unspecific error came up")
def main():
today = strftime('%Y%m%d')
batch_name = 'Median_Home_Values_Data_%s.csv' % today
# Mark all current jobs_data batches inactive
db_session.query(Batch).filter_by(datasource_id=5).update(
{'is_active': False})
batch = Batch(datasource_id=5, name=batch_name, is_active=True)
db_session.add(batch)
db_session.flush()
db_session.commit()
cities = db_session.query(City).order_by(City.code)
for city in cities:
print "city: %s" % city.code
data = get_home_values(city.code)
push_to_hadoop(data, batch_name)
push_to_sql(data, city.code, batch.batch_id)
def update(cls,
userId,
name=None,
account=None,
mobile=None,
address=None,
email=None,
identityCode=None,
yibaoCard=None,
passwd=None,
isBindPhone=None,
imagePath=None,
status=None):
if userId is None or userId < 1:
return
user = session.query(User).filter(User.id == userId).first()
if user:
if name:
user.name = name
if account:
user.account = account
if address:
user.address = address
if mobile:
user.phone = mobile
if email:
user.email = email
if identityCode:
user.identityCode = identityCode
if yibaoCard:
user.yibaoCard = yibaoCard
if passwd:
user.password = passwd
if isBindPhone:
user.isBindPhone = isBindPhone
if imagePath:
user.imagePath = imagePath
if status or status == 0:
user.status = status
session.commit()
session.flush()
return user
def main():
today = strftime('%Y%m%d')
batch_name = 'Jobs_Data_%s.csv' % today
# Mark all current jobs_data batches inactive
db_session.query(Batch).filter_by(datasource_id=6).update(
{'is_active': False})
batch = Batch(datasource_id=6, name=batch_name, is_active=True)
db_session.add(batch)
db_session.flush()
db_session.commit()
categories = range(1, 34)
for c in categories:
print "processing category %s" % c
data = get_job_stats(c)
push_to_hadoop(data, batch_name, c)
push_to_sql(data['response']['cities'], batch.batch_id, c)
db_session.close()
def submit():
import models
from database import db_session
#ensure webauth user hasn't already submitted
username = request.headers.get('x-webauth-user')
voted = True
try:
voted = models.Person.query.filter(
models.Person.uid == username).first().voted
except Exception:
print("User not in superlatives db! " + username)
if voted:
return jsonify({'error': "already voted"})
print(request.form)
print(request.json)
data = request.get_json()
answers = data['answers']
quote = data['quote']
history = data['history']
# Only vote once
models.Person.query.filter(
models.Person.uid == username).\
update(
{
"quote": quote,
"fav_history": history,
"voted": True
})
db_session.add(models.SuperlativeVote(answers))
db_session.flush()
db_session.commit()
return jsonify({'status': "ok"})
def save_results_and_cleanup(plots, simulation_id: int, step_id: int,
workdir: str):
output_path: str = workdir + "/plots/"
plots: List[Artifact] = index_plots(output_path, simulation_id, step_id)
reports: List[Artifact] = index_reports(workdir + "/reports/",
simulation_id, step_id)
simulation: Simulation = db_session.query(Simulation).get(simulation_id)
step: SimulationStep = db_session.query(SimulationStep).get(step_id)
db_session.flush()
db_session.begin()
end_time = datetime.datetime.utcnow()
simulation.finished_utc = end_time
simulation.status = 'SUCCESS'
step.finished_utc = end_time
step.status = 'SUCCESS'
db_session.add_all(plots)
db_session.add_all(reports)
db_session.add_all([simulation, step])
db_session.commit()
cleanup(workdir)
return workdir
def add_new_task():
user_id = current_user.id
description = request.form['description']
notes = request.form['notes']
longitude = request.form['longitude']
latitude = request.form['latitude']
attachment = None
#attachment = request.form['attachment']
category_name = request.form['category']
if category_name == '':
category_name = 'Default'
category = Category.query.filter(Category.name == category_name).first()
if not category:
category = Category(name=category_name)
db_session.add(category)
db_session.flush()
category_id = category.id
if request.form['due_date'] == '':
due_date = None
else:
due_date = datetime.strptime(request.form['due_date'], "%m/%d/%Y")
task = Task(user_id=user_id,
description=description,
notes=notes,
due_date=due_date,
longitude=longitude,
latitude=latitude,
attachment=attachment,
category_id=category_id)
db_session.add(task)
db_session.commit()
return jsonify(task.info())
def reports_step(self, simulation_id: int) -> None:
start_time = datetime.datetime.utcnow()
simulation: Simulation = db_session.query(Simulation).get(simulation_id)
step: SimulationStep = SimulationStep(started_utc=start_time,
origin="REPORT",
simulation_id=simulation.id,
status='ONGOING')
db_session.add(step)
db_session.flush()
workdir: str = simulation.workdir
output_path: str = workdir + "/plots/"
if not os.path.exists(output_path):
os.makedirs(output_path)
simulation.current_step = "REPORT"
simulation.current_step_id = step.id
db_session.begin()
db_session.add_all([simulation, step])
db_session.commit()
result = chain(
all_clones_plot_stats.s(workdir),
all_clones_mullerplot.s(),
noise_plot_stats.s(),
major_clones_plot_stats.s(),
major_clones_mullerplot.s(),
mullerplot.s(),
mutation_histogram.s(),
simulation_report.s(),
build_cell_model.s(),
save_results_and_cleanup.s(simulation_id, step.id, workdir),
).apply_async()
return result
def create_person(name, age, mail):
output = {'person': None, 'ok': False, 'mail': mail, 'message': ''}
person = db_session.query(Person).filter(
Person.name == name,
Person.age == age,
).order_by(Person.id.desc()).first()
if person:
output.update({'person': person, 'message': 'Person already added.'})
return output
mail_parts = mail.split('@')
if len(mail_parts) != 2:
output.update({'message': 'Incorrect mail provided.'})
return output
username, domain = mail_parts
domain_parts = domain.split('.')
if len(domain_parts) != 2:
output.update({'message': 'Incorrect mail provided.'})
return output
person = Person(name=name, age=age)
db_session.add(person)
db_session.flush()
email = Email(email=mail, person_id=person.id)
db_session.add(email)
db_session.commit()
output.update({
'ok': True,
'person': person,
'message': 'Person added successfully.'
})
return output
def updatePaidStatsStatus(cls, user, prevStatus, status):
if user is None or prevStatus is None or status is None:
return 0, None
if prevStatus == constant.DiagnosePayStatsConstant.Ongoing:
total = session.query(sa.func.sum(DiagnosePayStats.money)).filter(user == DiagnosePayStats.userId,
prevStatus == DiagnosePayStats.status,
datetime.today()+timedelta(days=-constant.RollbackPeriod)>DiagnosePayStats.finishDate)\
.group_by(DiagnosePayStats.userId).all()
result = session.query(DiagnosePayStats).filter(user == DiagnosePayStats.userId,
prevStatus == DiagnosePayStats.status,
datetime.today()+timedelta(days=-constant.RollbackPeriod)>DiagnosePayStats.finishDate)\
.update(dict(status=status))
else:
result = session.query(DiagnosePayStats).filter(user == DiagnosePayStats.userId,
prevStatus == DiagnosePayStats.status) \
.update(dict(status=status))
total = session.query(sa.func.sum(DiagnosePayStats)).filter(user == DiagnosePayStats.userId,
prevStatus == DiagnosePayStats.status)\
.group_by(DiagnosePayStats.userId).all()
session.commit()
session.flush()
if total and total > 0:
return total[0][0], result.id
return 0, result.id
