大家好，我是python222_小锋老师，看到一个不错的基于Python的Flask+Vue进销存仓库管理系统【论文+源码+SQL脚本】，分享下哈。
项目视频演示
https://www.bilibili.com/video/BV1udHtzNEcq/
项目介绍
基于Python的仓库管理系统的设计与实现是一项旨在通过自动化技术优化库存管理过程的工程。随着商业运营的不断扩大和多样化，传统的手动库存管理方式已经不能满足现代企业的需求。因此，开发一种高效、可靠且用户友好的系统成为了行业的迫切需求。本文将深入探讨基于Python的仓库管理系统的设计与实现过程，包括系统需求分析、系统设计、功能实现及测试结果。
首先，系统需求分析是设计任何软件项目的基础步骤。对于仓库管理系统而言，需求分析旨在明确系统应具备的功能和性能指标，如库存跟踪、订单处理、数据报告等。通过与业内专家和潜在用户的讨论，我们确定了系统的主要功能包括：自动化库存更新、商品入库和出库管理、库存预警、数据可视化报告等。此外，系统需要具备高度的可扩展性和用户友好性，以适应不断变化的商业需求和提高用户体验。
接下来，系统设计阶段是将需求分析阶段得到的信息转化为具体的系统架构和设计蓝图。本系统采用Python作为主要开发语言，利用其强大的库和框架，如Django或Flask用于Web后端开发，Pandas和NumPy用于数据处理，以及Matplotlib和Seaborn用于数据可视化。系统架构采用模块化设计，包括用户界面模块、数据处理模块、数据库模块和报告生成模块。此外，考虑到系统的安全性和数据保护，我们还引入了用户认证、数据加密和备份机制。
最后，功能实现及测试结果是验证系统设计有效性和可靠性的关键步骤。在开发过程中，我们采用敏捷开发方法，将项目分解为多个小的迭代周期，每个周期结束时都会进行代码审查和功能测试。测试过程包括单元测试、集成测试和系统测试，确保每个功能模块都能正常运行，并且整个系统能够稳定运行。测试结果显示，该仓库管理系统能够有效地处理库存数据，提高库存管理的效率和准确性。用户反馈也表明，系统界面直观易用，功能满足了他们的需求。
总之，基于Python的仓库管理系统的设计与实现是一个综合性项目，它不仅需要深入的需求分析和精心的系统设计，还需要高效的功能实现和严格的测试验证。通过本项目的实施，可以大大提高仓库管理的自动化水平和效率，为企业带来显著的经济效益和竞争优势。随着技术的不断进步和业务需求的变化，未来的仓库管理系统将继续向着更加智能化、个性化的方向发展。
系统展示
部分代码
# coding:utf-8
__author__ = "ila"
import logging, hashlib, copy,time,re
from flask import session
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy import desc,text
# from sqlalchemy.orm import load_only
from sqlalchemy.sql import func,and_,or_
from sqlalchemy import between
from ..exts import db
def Commit():
'''
commit提交方法
:return:
'''
error=None
try:
db.session.commit()
except SQLAlchemyError as e:
db.session.rollback()
error=str(e)
return error
class Base_model(db.Model):
__abstract__ = True
def __Create(self, data):
'''
插入数据公共方法
:param user:User
:return:
'''
#判断当前表名前两个字符是否为"wd",并且当前表有userid字段,20200301
if 'userid' in self.__table__.columns and self.__tablename__[:2]=='wd':
data['userid'] = session.get('params').get('id')
db.session.add(data)
return Commit()
def create(self, data):
'''
插入数据
:param user:User
:return:
'''
return self.__Create(data, data)
def __Retrieve(self, model):
'''
检索全部数据公共方法
:return:
'''
datas=model.query.all()
try:
data = [i.to_dict() for i in datas]
except:
data = datas
return data
def retrieve(self, model):
'''
检索全部数据
:return:
'''
return self.__Retrieve(model, model)
def __Update(self, data):
'''
更新某条记录公共方法
:param user:User
:return:
'''
db.session.add(data)
return Commit()
def update(self, data):
'''
更新某条记录
:param user:User
:return:
'''
return self.__Update(data, data)
def __Delete(self, ids):
'''
删除记录：先查询，再删除查询结果公共方法
:param user:
:return:
'''
self.query.filter(self.id.in_(ids)).delete(synchronize_session=False)
return Commit()
def delete(self, ids):
'''
删除记录：先查询，再删除查询结果
:param user:
:return:
'''
return self.__Delete(self, ids)
def __DeleteByParams(self,model, params):
'''
删除记录：先查询，再删除查询结果公共方法
:param user:
:return:
'''
self.query.filter_by(**params).delete(synchronize_session=False)
return Commit()
def deletebyparams(self, model,params):
'''
删除记录：先查询，再删除查询结果
:param user:
:return:
'''
return self.__DeleteByParams(self,model, params)
def __CreateByReq(self, model, req):
'''
根据请求参数创建对应模型记录的公共方法
:param model:
:param req:
:return:
'''
if model.__tablename__!= 'users':
req['id']=int(float(time.time())*1000)
column_list = []
for col in self.__table__.columns:
if str(col.type).lower() == "integer":
column_list.append(col.name)
for k, v in req.items():
if k in column_list and v == '':
req[k] = 0
column_list = []
for col in self.__table__.columns:
if str(col.type).lower() == "float":
column_list.append(col.name)
for k, v in req.items():
if k in column_list and v == '':
req[k] = 0.0
column_list = []
for col in self.__table__.columns:
if 'varchar' in str(col.type).lower():
column_list.append(col.name)
for k, v in req.items():
if k in column_list and v == '':
req[k] = ""
column_list = []
for col in self.__table__.columns:
if str(col.type).lower() == "datetime":
column_list.append(col.name)
for k, v in req.items():
if k in column_list and v == '':
req[k] = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
userid = False
for col in self.__table__.columns:
if str( col.name)=='userid':
if col.nullable==False:
userid=True
if userid==True :
if req.get("userid") =="" or req.get("userid") == None:
req['userid']=session.get("params").get('id')
for col in self.__table__.columns:
if str(col.name) not in req.keys() :
if col.nullable==False:
if "VARCHAR" in str(col.type) or "CHAR" in str(col.type):
req[str(col.name)]=""
m = model()
columns = self.getallcolumn(model, model)
for k, v in req.items():
if k in columns:
setattr(m, k, v)
db.session.add(m)
return Commit()
def createbyreq(self, model, req):
'''
根据请求参数创建对应模型记录
:param model:
:param req:
:return:
'''
return self.__CreateByReq(model, model, req)
def __GetById(self, model, id):
'''
根据id获取数据公共方法
:param id:
:return:
'''
data= model.query.filter_by(id=id).all()
try:
datas=[i if i.items else i.to_dict() for i in data]
except:
try:
datas = [i.to_dict() for i in data]
except:
datas = data
return datas
def getbyid(self, model, id):
'''
根据id获取数据
:param model:
:param id:
:return:
'''
return self.__GetById(self,model, id)
# def __GetByIds(self, model, ids):
# return self.query.filter(self.id.in_(ids)).all()
def __GetByParams(self, model, params):
# 根据接口传参来创建查询的公共方法
try:
__loginUser__=model.__loginUser__
except:
__loginUser__=None
if __loginUser__!=None:
if params.get('username'):
params[model.__loginUser__]=copy.deepcopy(params.get('username'))
del params['username']
if model.__tablename__ != 'users':
if params.get('password'):
params['mima'] = copy.deepcopy(params.get('password'))
del params['password']
members = [attr for attr in dir(model) if not attr.startswith("__")]
paramscopy = copy.deepcopy(params)
for key in paramscopy.keys():
if key not in members:
del params[key]
m = model.query.filter_by(**params).all()
#one,two,three
try:
mm=[i if i.items else i.to_dict() for i in m]
except:
try:
mm = [i.to_dict() for i in m]
except:
mm = m
return mm
def getbyparams(self, model, params):
# 根据接口传参来创建查询
return self.__GetByParams(model, model, params)
def __UpdateByParams(self, model, params):
'''
根据接口传参更新对应id记录的公共方法
:param model:
:param params:
:return:
'''
id_ = copy.deepcopy(params['id'])
del params['id']
column_list = []
for col in self.__table__.columns:
column_list.append(col.name)
newParams={}
for k,v in params.items():
if k in column_list:
ret = re.findall("\d{4}-\d{1,2}-\d{1,2} \d{2}:\d{2}:\d{2}", str(v))
if len(ret) > 0:
newParams[k] = ret[0]
else:
if params[k] != '':
newParams[k] = v
model.query.filter_by(id=int(id_)).update(
newParams
)
return Commit()
def updatebyparams(self, model, params):
'''
根据接口传参更新对应id记录
:param params:
:return:
'''
return self.__UpdateByParams(model, model, params)
def __Page(self, model, params, or_clauses):
'''
刷表专用
http://ip:port/${schemaName}/${tableName}/page
page 当前页
pagesize 每页记录的长度
sort 排序字段,写死在这,如果刷表出错，立马崩溃
order 升序（默认asc）或者降序（desc）
:param req_dict:
:return:
'''
sort = copy.deepcopy(params.get('sort'))
order = copy.deepcopy(params.get('order'))
page = copy.deepcopy(params.get('page')) if params.get('page') != None else 1
limit = copy.deepcopy(params.get('limit')) if params.get('limit') != None else 666
try:
del params['sort']
except:
pass
try:
del params['order']
except:
pass
try:
del params['page']
except:
pass
try:
del params['limit']
except:
pass
try:
__sort__=model.__sort__
except:
__sort__=None
#手工实现模糊搜索orz
fuzzy_key,fuzzy_val,contain_str=None,None,''
for k,v in params.items():
if "%" in v:
fuzzy_key=copy.deepcopy(k)
fuzzy_val=copy.deepcopy(v)
fuzzy_val=fuzzy_val.replace("%","")
if fuzzy_key != None:
contain_str +='.filter(model.{}.like("%{}%"))'.format(fuzzy_key,fuzzy_val)
if fuzzy_key!=None:
del params[fuzzy_key]
#__authSeparate__此属性为真，params添加userid，只查询个人数据
try:
__authSeparate__ = model.__sort__
except:
__authSeparate__ = None
if __authSeparate__ and __authSeparate__!="否":
if "userid" in self.getallcolumn(model,model) and session.get("params")!=None:
params["userid"]=session.get("params").get("id")
if "userid" not in self.getallcolumn(model,model) and "userid" in params.keys():
del params["userid"]
if sort!=None or __sort__!=None:
if sort==None:
sort=__sort__
if order == 'desc':
#del params['order']
# 传参判断，需要逆序
datas= model.query.filter_by(
**params
).filter(or_clauses).order_by(desc(text(sort))).paginate(
page=int(page),
per_page=int(limit),
error_out=False
)
else:
# 传参无逆序要求
# datas= model.query.filter_by(
# **params
# ).filter(or_clauses).order_by(text(sort)).paginate(
# page=int(page),
# per_page=int(limit),
# error_out=False
# )
datas=eval('''model.query.filter_by(
**params
){}.filter(or_clauses).order_by(text(sort)).paginate(
page=int(page),
per_page=int(limit),
error_out=False
)'''.format(contain_str))
else:
datas = model.query.filter_by(
**params
).filter(or_clauses).paginate(
page=int(page),
per_page=int(limit),
error_out=False
)
try:
data = [i if i.items else i.to_dict() for i in datas.items]
except:
try:
data = [i.to_dict() for i in datas.items]
except:
data = datas.items
newData=[]
if fuzzy_key is None:
newData=data
else:
for i in data:
for k,v in i.items():
if k==fuzzy_key and fuzzy_val in v:
newData.append(i)
#__authTables__
if session.get("tablename") == 'users':
return newData, datas.page, datas.pages, datas.total, datas.per_page
newDataa = []
if hasattr( self,"__authTables__") and self.__authTables__!={}:
par_keys=session.get("params",{}).keys()
authtables_keys=self.__authTables__.keys()
list1=list(set(par_keys).intersection(set(authtables_keys)))
if len(list1)>0:
for i in newData:
if i.get(list1[0])==session.get("params").get(list1[0]):
newDataa.append(i)
else:
newDataa=newData
else:
newDataa=newData
newDataa=newData
return newDataa,datas.page,datas.pages,datas.total,datas.per_page
def page(self, model, params, or_clauses=or_(*[])):
return self.__Page(self, model, params, or_clauses)
def __GetByColumn(self, model, column, params):
# data1= model.query.options(load_only(column)).all()
data1=model.query.filter_by(**params).with_entities(column).all()
data_list = []
for i in data1:
data_list.append(i[0])
return data_list
def getbyColumn(self, model, column, params):
'''
获取某表的某个字段的内容列表，去重
:param model:
:param column:
:return:
'''
return self.__GetByColumn(self, model, column, params)
# def __GetBetweenParams(self, model, columnName, params):
# '''
# :param model:
# :param params:
# :return:
# '''
# remindStart = copy.deepcopy(params.get("remindStart"))
# remindEnd = copy.deepcopy(params.get("remindEnd"))
# del params["remindStart"]
# del params["remindEnd"]
# #todo where是否合法
# datas= model.query.filter_by(**params).filter(between(columnName, remindStart, remindEnd))
# try:
# data = [i if i.items else i.to_dict() for i in datas]
# except:
# try:
# data = [i.to_dict() for i in datas]
# except:
# data = datas
# return data
def __GetBetweenParams(self, model, columnName, params):
'''
:param model:
:param params:
:return:
'''
remindStart = copy.deepcopy(params.get("remindStart"))
remindEnd = copy.deepcopy(params.get("remindEnd"))
del params["remindStart"]
del params["remindEnd"]
contain_str = '.filter(model.{}.between(remindStart, remindEnd))'.format(columnName)
#todo where是否合法
datas= eval('''model.query.filter_by(**params){}'''.format(contain_str))
try:
data = [i if i.items else i.to_dict() for i in datas]
except:
try:
data = [i.to_dict() for i in datas]
except:
data = datas
return data
def getbetweenparams(self, model, columnName, params):
'''
区域内查询
:param model:
:param params:
:return:
'''
return self.__GetBetweenParams( self,model, columnName, params)
def __GetComputedByColumn(self, model, columnName):
return db.session.query(
func.sum(getattr(model, columnName)).label("sum"),
func.max(getattr(model, columnName)).label("max"),
func.min(getattr(model, columnName)).label("min"),
func.avg(getattr(model, columnName)).label("avg"),
).all()
def getcomputedbycolumn(self, model, columnName):
'''
求和最大最小平均值
:param model:
:param columnName:
:return:
'''
return self.__GetComputedByColumn(self, model, columnName)
def __GroupByColumnName(self, model, columnName, params):
datas = db.session.query(getattr(model, columnName),func.count(getattr(model, columnName))).group_by(getattr(model, columnName)).filter_by(**params).all()
try:
data = [i.to_dict() for i in datas]
except:
data = datas
data=[{columnName:x[0],"total":float(x[1])} for x in data]
return data
def groupbycolumnname(self, model, columnName, params={}):
'''
类别统计
:param model:
:param params:
:return:
'''
return self.__GroupByColumnName(self, model, columnName, params)
def __GetValueByxyColumnName(self,model,xColumnName,yColumnName,params):
'''
内部函数
:param model:
:param xColumnName:
:param yColumnName:
:return:
'''
datas=db.session.query(getattr(model,xColumnName),func.sum(getattr(model,yColumnName))).group_by(getattr(model,xColumnName)).filter_by(**params).all()
try:
data = [i.to_dict() for i in datas]
except:
data = datas
data = [{xColumnName: x[0], "total": float(x[1])} for x in data]
return data
def getvaluebyxycolumnname(self,model,xColumnName,yColumnName,params={}):
'''
:param model:
:param xColumnName:
:param yColumnName:
:return:
'''
return self.__GetValueByxyColumnName(self,model,xColumnName,yColumnName,params)
def getallcolumn(self, model):
"""
把一条记录转成字典
:returns dict:
"""
return [c.name for c in model.__table__.columns]
def to_dict(self):
"""
把一条记录转成字典
:returns dict:
"""
data= {c.name: str(getattr(self, c.name)) for c in self.__table__.columns}
dataa={}
for k,v in data.items():
if v==None or v=="None":
dataa[k]=""
else:
dataa[k] = v
return dataa
def set_password(self, password) -> str:
'''
设置密码
:param password:
:return:
'''
m = hashlib.md5()
m.update(password.encode("utf-8"))
passwd = m.hexdigest()
logging.warning("password.md5 : {}".format(passwd))
return passwd
def check_password(self, hash, password) -> bool:
'''
验证密码
:param hash:
:param password:
:return:
'''
m = hashlib.md5()
m.update(password.encode("utf-8"))
return True if hash == m.hexdigest() else False
def count(self, model, params):
list_count = db.session.query(func.count(getattr(model, 'id'))).filter_by(**params).scalar()
return list_count
# coding:utf-8
__author__ = 'ila'
from datetime import datetime
from api.models.models import Base_model
from api.exts import db
# 个人信息
class users(Base_model):
__doc__ = 'admin表'
__tablename__ = 'users'
id = db.Column(db.BigInteger, primary_key=True)
username = db.Column(db.String(100), nullable=False, info='用户名')
password = db.Column(db.String(100), nullable=False, info='密码')
role = db.Column(db.String(100), server_default=db.FetchedValue(), info='角色')
addtime = db.Column(db.DateTime, nullable=False, default=datetime.now,server_default=db.FetchedValue(), info='新增时间')源码下载
链接：https://pan.baidu.com/s/1v27uU9xwxKVc9RlCTrRiAw
提取码：1234
