def pu_add(ip, html, product_id="", product_name=""):
try:
session = get_session()
current_month = datetime.datetime.now().strftime('%Y-%m-%d')+" 00:00:00"
query = api.model_query(session, "Product_PU", {"ip": [ip], "html": [html], "visit_date": [current_month]})
if query.count() == 0:
data = {
"ip": ip,
"html": html,
"product_id": product_id,
"product_name": product_name,
"pu_count": 1,
"visit_date": current_month
}
data = api.convert_model("Product_PU", data)
session.add(data)
else:
current_pu = query.first()
current_pu.pu_count += 1
#query.update({
# models.Product_PU.pu_count: current_pu.pu_count +1
#})
session.commit()
return True
except Exception as ex:
gen_log.error("pu add error:%r" % ex)
return False
finally:
session.close()
def get_pu(ip="", html="", start="", end=""):
try:
session = get_session()
# verify date
if start and not is_date(start):
gen_log.info("start format error:%s, %s"%(start, type(start)))
return []
if end and not is_date(end):
gen_log.info("end format error:%s, %s" % (end, type(start)))
return []
query = api.get_pu_count(session, ip, html, start, end)
results = query.all()
_ = []
for result in results:
_.append({
"ip": result.ip,
"html": result.html,
"count": int(result[2])
})
return _
except Exception as ex:
gen_log.error("pu query error:%r"%ex)
return []
finally:
session.close()
def get_product(**kwargs):
id = kwargs.get("id", "")
name = kwargs.get("name", "")
offset = kwargs.get("offset", 0)
limit = kwargs.get("limit", 0)
try:
session = get_session()
results = []
if id:
query = api.model_query(session, "Product", {"id": [id]})
result = query.first()
if result:
results.append(result.to_dict())
return init_like_count(session, results)
if name:
query = api.model_query(session, "Product", {"name": [name]})
result = query.first()
if result:
results.append(result.to_dict())
return init_like_count(session, results)
query = api.model_query(session, "Product", {})
results = query.order_by("sort_num").all()
results = [result.to_dict() for result in results]
return init_like_count(session, results)
except Exception as ex:
gen_log.error("Get product error:%r" % ex)
return []
finally:
session.close()
def update_product(productinfo, con_dic):
"""
更新产品
:param productinfo:{"name": "sdfds"}
:param con_dic: {"name": ["sdfdsd"]}
:return:
"""
try:
session = get_session()
sort_num = productinfo.get("sort_num", 10000)
if sort_num == 0:
productinfo.update({"sort_num": 10000})
if sort_num > 0 and sort_num < 10000:
api.set_product_sort_num(session, sort_num)
name = productinfo.get("name", "")
_ = verify_product(session, name)
if _ != 0:
return False
query = api.model_query(session, "Product", con_dic)
query.update(productinfo, synchronize_session=False)
session.commit()
return True
except Exception as ex:
gen_log.error("update user error:%r" % ex)
return False
finally:
session.close()
def get_creating_user(**kwargs):
email = kwargs.get("email", "")
user_name = kwargs.get("name", "")
gen_log.info("user name:%s" % user_name)
try:
#email = bs2unicode(email)
session = get_session()
if email:
gen_log.info(1)
query = api.model_query(session, "User", {
"email": [email],
"status": ["creating"]
})
result = query.first()
return result
if user_name:
gen_log.info(2)
query = api.model_query(session, "User", {
"name": [user_name],
"status": ["creating"]
})
result = query.first()
return result
except Exception as ex:
gen_log.error("get creating user error:%r" % ex)
finally:
session.close()
def verify_user(session, name="", email="", telephone=""):
"""
验证用户名、邮箱、手机号码不能重复
:param name:
:param email:
:param telephone:
:return: 0：没有重复；1：邮箱重复；2：用户名重复；3：电话号码重复；4：代码错误
"""
try:
if email:
query = api.model_query(session, "User", {"email": [email]})
if query.count() > 0:
return 1
if name:
query = api.model_query(session, "User", {"name": [name]})
if query.count() > 0:
return 2
if telephone:
query = api.model_query(session, "User",
{"telephone": [telephone]})
if query.count() > 0:
return 3
if not email and not name and not telephone:
return 4
return 0
except Exception as ex:
gen_log.error("get available user error:%r" % ex)
raise ex
def get_company():
try:
session = get_session()
query = api.model_query(session, "Company", {})
_ = query.first()
return _.to_dict()
except Exception as ex:
gen_log.error("get all company error:%r"%ex)
return {}
finally:
session.close()
def update_company(company_info, company_name):
try:
session = get_session()
query = api.model_query(session, "Company", {"name": [company_name]})
query.update(company_info, synchronize_session=False)
session.commit()
return True
except Exception as ex:
gen_log.error("update company error:%r" % ex)
return False
finally:
session.close()
def del_user(user_name):
try:
session = get_session()
query = api.model_query(session, "User", {"name": [user_name]})
query.delete(synchronize_session=False)
session.commit()
return 0
except Exception as ex:
gen_log.error("del user error:%r" % ex)
return 1
finally:
session.close()
def convert_model(class_name, info_dic):
"""
字典->model
:param class_name:
:param info_dic:
:return:
"""
try:
class_model = getattr(models, class_name)
model = class_model()
for k, v in info_dic.iteritems():
setattr(model, k, v)
return model
except Exception as ex:
gen_log.error("%s convert error: %r" % (class_name, ex))
def get_product_by_names(product_names):
try:
session = get_session()
query = api.model_query(
session, "Product", {
"name":
product_names
if isinstance(product_names, list) else [product_names]
})
results = query.all()
return [result.to_dict() for result in results]
except Exception as ex:
gen_log.error("Get product by name error:%r" % ex)
finally:
session.close()
def get_keyword_like_count(keyword_id):
try:
session = get_session()
query = api.model_query(session, "ProductKeyword", {"id": [keyword_id]})
result = query.first()
if not result:
return 0
query = api.model_query(session, "User_Like", {"keyword_id": [keyword_id]})
real_count = query.count()
return real_count + result.like_add_count
except Exception as ex:
gen_log.error("Query keyword like count error:%r."%ex)
return 0
finally:
session.close()
def del_product(product_names):
try:
session = get_session()
query = api.model_query(
session, "Product", {
"name":
product_names
if isinstance(product_names, list) else [product_names]
})
query.delete(synchronize_session=False)
session.commit()
return True
except Exception as ex:
gen_log.error("del product error:%r" % ex)
return False
finally:
session.close()
def del_keyword(keyword_name):
try:
session = get_session()
query = api.model_query(
session, "ProductKeyword", {
"name":
keyword_name
if isinstance(keyword_name, list) else [keyword_name]
})
query.delete(synchronize_session=False)
session.commit()
return True
except Exception as ex:
gen_log.error("del keyword error:%r" % ex)
return False
finally:
session.close()
def model_query(session, class_name, query_dict):
"""
通用查询，单元测试ut
:param session:
:param class_name: 实体名
:param query_dict: 查询条件，格式：{'device_name':['FWQSB'], 'device_sn':['27350626']}
:return: query
"""
try:
class_model = getattr(models, class_name)
query = session.query(class_model)
for key, value in query_dict.iteritems():
column_name = getattr(class_model, key)
query = query.filter(getattr(column_name, 'in_')(value))
return query
except Exception as ex:
gen_log.error("%s query error: %r" % (class_name, ex))
raise ex
def update_user(userinfo, con_dic):
"""
更新用户
:param userinfo: 字典，key必须和models.User匹配，待更新的用户信息
:param con_dic: 字典，待更新的条件
:return:
"""
try:
session = get_session()
query = api.model_query(session, "User", con_dic)
query.update(userinfo, synchronize_session=False)
session.commit()
return True
except Exception as ex:
gen_log.error("update user error:%r" % ex)
return False
finally:
session.close()
def post(self):
product_name = self.get_argument("product_name")
_p_names = product_name.split("|")
_all_product = loc_product.get_product_by_names(_p_names)
_ = loc_product.del_product(_p_names)
if not _:
self.finish({'state': '1', 'message': 'delete product faild'})
return
# del img
try:
upload_path = os.path.abspath(os.path.dirname(__file__) + os.path.sep + "..")
upload_path = os.path.join(upload_path, 'static')
for product in _all_product:
os.remove(os.path.join(upload_path, product.get("img_path")))
except Exception as ex:
gen_log.error("del product img error:%r"%ex)
self.finish({'state': '0', 'message': 'delete product ok'})
def post(self):
keyword_name = self.get_argument("keyword_name")
_k_names = keyword_name.split("|")
_all_keyword = loc_keywod.get_keyword_by_names(_k_names)
_ = loc_keywod.del_keyword(_k_names)
if not _:
self.finish({'state': '1', 'message': 'delete keyword faild'})
return
# del img
try:
upload_path = os.path.abspath(
os.path.dirname(__file__) + os.path.sep + "..")
upload_path = os.path.join(upload_path, 'static')
for keyword in _all_keyword:
os.remove(os.path.join(upload_path, keyword.get("img_path")))
except Exception as ex:
gen_log.error("del product img error:%r" % ex)
self.finish({'state': '0', 'message': 'delete keyword ok'})
def get_product_like_theme(product_keyword, offset=0, limit=0):
"""
获取产品列表，根据关键字模糊查询
:param product_keyword:
:return:
"""
if not product_keyword:
return
try:
session = get_session()
query = api.get_product_like_theme(session, product_keyword)
results = query.order_by("sort_num").all()
results = [result.to_dict() for result in results]
return init_like_count(session, results)
except Exception as ex:
gen_log.error("like query product error: %r" % ex)
finally:
session.close()
def get_all_user():
"""
获取所有的用户
:return:
"""
try:
session = get_session()
query = api.model_query(session, "User", {})
results = query.all()
_result = []
for result in results:
result.pwd = ""
_result.append(result.to_dict())
return _result
except Exception as ex:
gen_log.error("get all user error:%r" % ex)
return []
finally:
session.close()
def is_exit_avai_email(email=""):
if not email:
raise ValueError('email is none')
try:
#email = bs2unicode(email)
session = get_session()
query = api.model_query(session, "User", {
"email": [email],
"status": ["available"]
})
result = query.first()
if result:
return True
return False
except Exception as ex:
gen_log.error("exit email error:%r" % ex)
raise ex
finally:
session.close()
def get(self):
user_name = self.get_argument('user_name', '')
val_code = self.get_argument("val_code", "")
redirect_url = self.get_argument("redirect_url", "")
if not redirect_url:
redirect_url = "home.html"
user_info = loc_user.get_available_user(name=user_name)
if not user_info:
gen_log.error("user info is none")
redirect_url = "login.html"
self.redirect(self.prefix + redirect_url, permanent=True)
return
#判断验证码
if user_info.valcode != val_code:
gen_log.error("val code:%s,%s" % (user_info.valcode, val_code))
redirect_url = "login.html"
self.redirect(self.prefix + redirect_url, permanent=True)
return
#更新用户密码
loc_user.update_user(
{
"pwd": encry_md5(user_info.reset_pwd),
"reset_pwd": ""
}, {"name": [user_name]})
# 设置cookie，注册的，默认都是1
self.set_secure_cookie("user_name",
user_name,
expires=time.time() + float(com_cookie_time))
self.set_secure_cookie("user_level",
str(user_info.level),
expires=time.time() + float(com_cookie_time))
# 管理员跳转管理页面
if user_info.level == 0:
self.redirect(self.manage_prefix + "manproduct.html")
return
self.redirect(self.prefix + redirect_url, permanent=True)
def add_product(productinfo):
try:
name = productinfo.get("name", "")
session = get_session()
_ = verify_product(session, name)
if _ != 0:
return False
sort_num = productinfo.get("sort_num", 10000)
if sort_num <= 0:
productinfo.update({"sort_num": 10000})
if sort_num > 0 and sort_num < 10000:
api.set_product_sort_num(session, sort_num)
model_user = api.convert_model("Product", productinfo)
session.add(model_user)
session.commit()
return True
except Exception as ex:
gen_log.error("add user error:%r" % ex)
raise ex
finally:
session.close()
def add_keyword(keywordinfo):
try:
name = keywordinfo.get("name", "")
session = get_session()
_ = verify_keyword(session, name)
if _ != 0:
return False
sort_num = keywordinfo.get("sort_num", 10000)
if sort_num == 0:
keywordinfo.update({"sort_num": 10000})
if sort_num > 0 and sort_num < 10000:
api.set_keyword_sort_num(session, sort_num)
model_keyword = api.convert_model("ProductKeyword", keywordinfo)
session.add(model_keyword)
session.commit()
return True
except Exception as ex:
gen_log.error("add keyword error:%r" % ex)
raise ex
finally:
session.close()
def add_user(userinfo):
"""
添加用户
:param userinfo: 字典，key必须和models.User匹配
:return:
"""
try:
email = userinfo.get("email", "")
name = userinfo.get("name", "")
telephone = userinfo.get("telephone", "")
session = get_session()
_ = verify_user(session, name, email, telephone)
if _ != 0:
return False
model_user = api.convert_model("User", userinfo)
session.add(model_user)
session.commit()
return True
except Exception as ex:
gen_log.error("add user error:%r" % ex)
return False
finally:
session.close()
def get_available_user(**kwargs):
email = kwargs.get("email", "")
user_name = kwargs.get("name", "")
try:
session = get_session()
if email:
query = api.model_query(session, "User", {
"email": [email],
"status": ["available"]
})
result = query.first()
return result
if user_name:
query = api.model_query(session, "User", {
"name": [user_name],
"status": ["available"]
})
result = query.first()
return result
except Exception as ex:
gen_log.error("get available user error:%r" % ex)
finally:
session.close()
def hot_send_email(to_email, message, subject, msg_type="plain"):
global _LOCK
with _LOCK:
try:
#service_smtp = smtplib.SMTP("smtp-mail.outlook.com", 587)
service_smtp = smtplib.SMTP("smtp.live.com", 587)
msg = MIMEText(message, msg_type)
msg["Subject"] = subject
msg["From"] = hot_email_user
msg["To"] = to_email
service_smtp.ehlo(
) # Hostname to send for this command defaults to the fully qualified domain name of the local host.
service_smtp.starttls(
) #Puts connection to SMTP server in TLS mode
service_smtp.ehlo()
service_smtp.login(hot_email_user, hot_email_pwd)
service_smtp.sendmail(hot_email_user, to_email, msg.as_string())
service_smtp.close()
return True
except smtplib.SMTPException, e:
gen_log.error("send email error:%r" % e)
return False
finally:
def update_keyword(keywordinfo, con_dic):
try:
session = get_session()
name = keywordinfo.get("name", "")
_ = verify_keyword(session, name)
if _ != 0:
return False
sort_num = keywordinfo.get("sort_num", 10000)
if sort_num == 0:
keywordinfo.update({"sort_num": 10000})
if sort_num > 0 and sort_num < 10000:
api.set_keyword_sort_num(session, sort_num)
query = api.model_query(session, "ProductKeyword", con_dic)
query.update(keywordinfo, synchronize_session=False)
session.commit()
return True
except Exception as ex:
gen_log.error("update keyword error:%r" % ex)
return False
finally:
session.close()
def gmail_send_email(to_email, message, subject, msg_type="plain"):
global _LOCK
with _LOCK:
try:
# Create SMTP Object
msg = MIMEText(message, msg_type)
msg['From'] = gmail_email_user
msg['To'] = to_email
msg['Subject'] = subject
service_smtp = smtplib.SMTP('smtp.gmail.com', 587)
except Exception, e:
gen_log.error("send email conncet error:%r" % e)
return False
try:
service_smtp.starttls()
# login with username & password
service_smtp.login(gmail_email_user, gmail_email_pwd)
service_smtp.sendmail(gmail_email_user, to_email, msg.as_string())
return True
except smtplib.SMTPException, e:
gen_log.error("send email smtp error:%r" % e)
return False
def qq_send_email(to_email, message, subject, msg_type="plain"):
"""
发送邮件
:param to_email: 接收邮箱
:param message: 发送内容
:param subject: 邮件标题
:return:
"""
global _LOCK
with _LOCK:
try:
service_smtp = smtplib.SMTP_SSL("smtp.qq.com", 465)
msg = MIMEText(message, msg_type)
msg["Subject"] = subject
msg["From"] = qq_email_user
msg["To"] = to_email
service_smtp.login(qq_email_user, qq_email_pwd)
service_smtp.sendmail(qq_email_user, to_email, msg.as_string())
service_smtp.close()
return True
except smtplib.SMTPException, e:
gen_log.error("send email error:%r" % e)
return False
finally:
