class Rules_White_IP_URL(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_White_IP_URL'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
ip = db.Column(db.String(15), nullable=True)
mask = db.Column(db.SmallInteger, nullable=True)
url = db.Column(db.String(5000))
description = db.Column(db.String(2000))
type = db.Column(db.String(2000))
cre_dt = db.Column(db.DateTime, server_default=func.now())
mod_dt = db.Column(db.DateTime)
del_yn = db.Column(db.String(1), default='N')
def __init__(self ):
return
def __repr__(self):
return '<Rules_White_IP_URL %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
# d['mod_dt'] = self.mod_dt.strftime("%Y-%m-%d") if self.mod_dt is not None else ''
return d
class TI_Dashboard_data(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'TI_Dashboard_data'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
div_id = db.Column(db.String(45))
title = db.Column(db.String(200))
url = db.Column(db.String(2000))
# EName = db.Column(db.String(255))
# UseYn = db.Column(db.String(2))
# SortOrder = db.Column(db.Integer )
# EXT1 = db.Column(db.String(2048))
# EXT2 = db.Column(db.String(2048))
# EXT3 = db.Column(db.String(2048))
# EXT4 = db.Column(db.String(2048))
# EXT5 = db.Column(db.String(2048))
# MoDatetime = db.Column(db.DateTime)
# relation
#rules_CNC = db.relationship("Rules_CNC", uselist=False, back_populates='commonCode')
def __init__(self, code):
self.Code = code
def __repr__(self):
return '<TI_Dashboard_data %r>' % (self.id)
def serialize(self):
d = Serializer.serialize(self)
return d
class Rules_IP_Collection(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_IP_Collection'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
ip = db.Column(db.String(20), nullable=False)
mask = db.Column(db.Integer, nullable=False)
detection_point = db.Column(db.String(200))
description = db.Column(db.String(2000))
etc = db.Column(db.String(2000))
use_yn = db.Column(db.String(1))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
#del_yn = db.Column(db.String(1), default='N')
def __init__(self):
return
def __repr__(self):
return '<Rules_IP_Collection %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
return d
class CycleConfig(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'CycleConfig'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
Section = db.Column(db.String(255))
Type = db.Column(db.String(255))
Value = db.Column(db.String(255))
class Integrated_Type_Category(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Type_Category_Management'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
Field_Name = db.Column(db.String(255), unique=True, nullable=True)
# IP_Address = db.Column(db.String(15), nullable=True)
# mask = db.Column(db.SmallInteger, nullable=True)
Description = db.Column(db.String(1000))
# Password = db.Column(db.String(100))
# description = db.Column(db.String(2000))
# type = db.Column(db.String(2000))
# cre_dt = db.Column(db.DateTime, server_default=func.now())
# mod_dt = db.Column(db.DateTime)
# del_yn = db.Column(db.String(1), default='N')
def __init__(self):
return
def __repr__(self):
return '<Type_Category_Management %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
# d['mod_dt'] = self.mod_dt.strftime("%Y-%m-%d") if self.mod_dt is not None else ''
return d
class Manual_Crawling_Info(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Manual_Crawling_Info'
# region parameter input
idx = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
unique=True)
url = db.Column(db.String(5000), nullable=False)
depth = db.Column(db.SmallInteger, nullable=True, default=1)
comment = db.Column(db.String(100), nullable=True)
register_from = db.Column(db.String(100), nullable=True)
register_date = db.Column(db.DateTime, server_default=func.now())
del_yn = db.Column(db.String(1), nullable=False, default='n')
result_yn = db.Column(db.String(1), nullable=False, default="n")
def __init__(self):
return
def __repr__(self):
return '<Manual_Crawling_Info %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
# d['mod_dt'] = self.mod_dt.strftime("%Y-%m-%d") if self.mod_dt is not None else ''
return d
class DNA_StandardData(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'DNA_StandardData'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(2000), nullable=False)
list_data = db.Column(db.String(5000), nullable=False)
list_size = db.Column(db.Integer, nullable=False, default=0)
target_link_type = db.Column(db.String(10))
target_link_seq = db.Column(db.Integer)
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
mod_dt = db.Column(db.DateTime)
use_yn = db.Column(db.String(1), default='Y')
del_yn = db.Column(db.String(1), default='N')
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
d = Serializer.serialize(self)
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d %H:%M:%S")
d['mod_dt'] = self.mod_dt.strftime("%Y-%m-%d %H:%M:%S") if self.mod_dt is not None else ''
return d
class Rules_WhiteList(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_WhiteList'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
md5 = db.Column(db.String(1000), nullable=False)
description = db.Column(db.String(2000))
source = db.Column(db.BigInteger, db.ForeignKey(CommonCode.idx))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
del_yn = db.Column(db.String(1), default='N')
source_commonCode = db.relationship("CommonCode", order_by="CommonCode.SortOrder", foreign_keys=[source])
def __init__(self ):
return
def __repr__(self):
return '<Rules_WhiteList %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
del d['source_commonCode']
d['source_name'] = self.source_commonCode.EXT1
d['source_code'] = self.source_commonCode.Code
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d")
return d
class malicious_info(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'malicious_info'
# region parameter input
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
url = db.Column(db.String(3000), nullable=False)
ip = db.Column(db.String(15))
country_code = db.Column(db.String(10))
file_name = db.Column(db.String(1000), nullable=False)
md5 = db.Column(db.String(100))
detect_info = db.Column(db.String(100))
collect_point = db.Column(db.String(100))
comment = db.Column(db.String(100))
stix = db.Column(db.Text())
file_path = db.Column(db.String(1000))
# description = db.Column(db.String(2000))
#del_yn = db.Column(db.String(1), default='N')
def __init__(self):
return
def __repr__(self):
return '<malicious_info %r>' % (self.id)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
return d
class Account(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Account'
id = db.Column(db.String(100), primary_key=True, unique=True)
password = db.Column(db.String(500))
email = db.Column(db.String(500))
mobile = db.Column(db.String(500))
role_id = db.Column(db.String(255)) #Common Code
culture = db.Column(db.String(500))
comment = db.Column(db.String(2000))
last_pass_change_date = db.Column(db.DateTime)
last__login_date = db.Column(db.DateTime)
login_fail_date = db.Column(db.DateTime)
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
cre_id = db.Column(db.String(500))
login_fail_cnt = db.Column(db.Integer, default=0)
blockCode = db.Column(db.String(255)) #Common Code
login_fail_dt = db.Column(db.DateTime)
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
d = Serializer.serialize(self)
return d
class LinkDnaLog(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'LinkDnaLog'
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
id = db.Column(db.String(100))
ip = db.Column(db.String(100))
importance = db.Column(db.Integer)
description = db.Column(db.String(3000))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
def serialize(self):
d = Serializer.serialize(self)
d['cre_dt'] = d['cre_dt'].strftime("%Y-%m-%d %H-%M-%S")
return d
class Link_Element_TypeA(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Link_Element_TypeA'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
src_type = db.Column(db.String(2000), nullable=False)
src_columns_name = db.Column(db.String(500), nullable=False)
dst_columns_name = db.Column(db.String(500), nullable=False)
operate_function = db.Column(db.String(2000), nullable=True)
dst_data_type = db.Column(db.String(2000), nullable=True, default="single")
dst_data_size = db.Column(db.Integer, nullable=True)
description = db.Column(db.String(2000))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
mod_dt = db.Column(db.DateTime)
use_yn = db.Column(db.String(1), default='Y')
del_yn = db.Column(db.String(1), default='N')
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
d = Serializer.serialize(self)
return d
class wl_maintenance_period(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'wl_maintenance_period'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
wl_maintenance_period = db.Column(db.Integer)
datatype = db.Column(db.String(45))
# seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
# ip = db.Column(db.String(15), nullable=True)
# mask = db.Column(db.SmallInteger, nullable=True)
# url = db.Column(db.String(5000))
# description = db.Column(db.String(2000))
# type = db.Column(db.String(2000))
# cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
# mod_dt = db.Column(db.DateTime)
# del_yn = db.Column(db.String(1), default='N')
def __init__(self):
return
def __repr__(self):
return '<wl_maintenance_period %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
# d['mod_dt'] = self.mod_dt.strftime("%Y-%m-%d") if self.mod_dt is not None else ''
return d
class DNA_Schedule(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'DNA_Schedule'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
dna_id = db.Column(db.Integer, db.ForeignKey(DNA_Element.id), nullable=False)
description = db.Column(db.String(2000), nullable=False)
filter_ip = db.Column(db.String(500), nullable = True)
filter_data_type = db.Column(db.String(500), nullable = True)
cycle = db.Column(db.String(500), nullable = True)
start_time = db.Column(db.DateTime, default=datetime.datetime.now())
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
cre_id = db.Column(db.String(500), nullable = True)
restart_request = db.Column(db.Integer, default=0)
proceed_state = db.Column(db.String(500), nullable = True, default='대기중')
del_yn = db.Column(db.String(1), default='N')
dna = db.relationship("DNA_Element")
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
d = Serializer.serialize(self)
del d['dna']
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d %H:%M:%S")
d['start_time'] = self.start_time.strftime("%Y-%m-%d %H:%M:%S")
return d
class Integrated_Inter_Operation_Policy(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Inter_Operation_Policy'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
Type = db.Column(db.String(255), nullable=False)
IPS_Policy = db.Column(db.String(255), unique=True, nullable=False)
IPS_Policy_No = db.Column(db.String(255), nullable=False)
Mal_IP = db.Column(db.String(500), nullable=False)
Target_IP = db.Column(db.String(500), nullable=False)
Mal_IP_Type = db.Column(db.String(255), nullable=False)
Regular_Exp_Name = db.Column(db.String(255), nullable=False)
Security_Log_Use = db.Column(db.Boolean, nullable=False)
TI_Log_Use = db.Column(db.Boolean, nullable=False)
# IP_Address = db.Column(db.String(15), nullable=True)
# mask = db.Column(db.SmallInteger, nullable=True)
# Description = db.Column(db.String(1000))
# Password = db.Column(db.String(100))
# description = db.Column(db.String(2000))
# type = db.Column(db.String(2000))
# cre_dt = db.Column(db.DateTime, server_default=func.now())
# mod_dt = db.Column(db.DateTime)
# del_yn = db.Column(db.String(1), default='N')
def __init__(self ):
return
def __repr__(self):
return '<Inter_Operation_Policy %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
# d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d") if self.cre_dt is not None else ''
# d['mod_dt'] = self.mod_dt.strftime("%Y-%m-%d") if self.mod_dt is not None else ''
return d
class IP_WhiteList(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'IP_WhiteList'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
ip = db.Column(db.String(20))
description = db.Column(db.String(2000))
def __init__(self, ip):
self.ip = ip
def __init__(self):
return
def __repr__(self):
return '<ip %r>' % self.ip
def serialize(self):
d = Serializer.serialize(self)
return d
class DNA_Element(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'DNA_Element'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
dna_name = db.Column(db.String(500), nullable=False)
operate_function = db.Column(db.String(10000), nullable=False)
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
mod_dt = db.Column(db.DateTime)
use_yn = db.Column(db.String(1), default='Y')
del_yn = db.Column(db.String(1), default='N')
sector_list = []
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
self.getSectorList()
d = Serializer.serialize(self)
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d %H:%M:%S")
d['mod_dt'] = self.mod_dt.strftime(
"%Y-%m-%d %H:%M:%S"
) if self.mod_dt is not None else self.cre_dt.strftime(
"%Y-%m-%d %H:%M:%S")
d['sector_list'] = self.sector_list
return d
def getSectorList(self):
op = json.loads(self.operate_function)
self.sector_list = []
for _sec in op['dna_name_list']:
self.sector_list.append({
"name": _sec['dna_name'],
"desc": _sec['desc'],
"comment": _sec['comment']
})
class GlobalSetting(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'GlobalSetting'
key = db.Column(db.String(20), primary_key=True)
value = db.Column(db.String(20))
name = db.Column(db.String(200))
description = db.Column(db.String(2000))
def __init__(self, ip):
self.ip = ip
def __init__(self):
return
def __repr__(self):
return '<ip %r>' % self.ip
def serialize(self):
d = Serializer.serialize(self)
return d
class Rules_Profile_Group(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_Profile_Group'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(500))
time_gubun = db.Column(db.String(100))
time_value = db.Column(db.Integer)
description = db.Column(db.String(2000))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
del_yn = db.Column(db.String(1), default='N')
def __init__(self):
return
def __repr__(self):
return '<Rules_Profile_Group %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d")
return d
class Link_Element_TypeB(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Link_Element_TypeB'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
dst_columns_name = db.Column(db.String(500), nullable=False)
description = db.Column(db.String(2000))
operate_function = db.Column(db.String(2000), nullable=False)
analysis_cycle = db.Column(db.String(100), nullable=False)
timespan = db.Column(db.String(100), nullable=False)
dst_data_type = db.Column(db.String(2000), nullable=True, default="list")
dst_data_size = db.Column(db.Integer, nullable=True)
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
mod_dt = db.Column(db.DateTime)
use_yn = db.Column(db.String(1), default='Y')
del_yn = db.Column(db.String(1), default='N')
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
d = Serializer.serialize(self)
return d
def setOperateFunction(self, cols, op, time_range):
result = {"org_elements": []}
for row in cols:
rowDict = {
"org_type": row["type"],
"org_id": row["id"],
"operate": row["op"]
}
result["org_elements"].append(rowDict)
if cols.__len__() > 1:
result["operate_between"] = op
if time_range is not None:
result["time_range"] = time_range
self.operate_function = json.dumps(result)
class Rules_CNC(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_CNC'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
pattern_uri = db.Column(db.String(2000))
category = db.Column(db.String(200))
rule_type = db.Column(db.BigInteger, db.ForeignKey(CommonCode.idx))
analysis_device = db.Column(db.String(2000))
analysis_result = db.Column(db.String(200))
detection_source = db.Column(db.String(200))
description = db.Column(db.String(2000))
source = db.Column(db.BigInteger, db.ForeignKey(CommonCode.idx))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
del_yn = db.Column(db.String(1), default='N')
country_code = db.Column(db.String(200))
mod_dt = db.Column(db.DateTime, default=datetime.datetime.now())
rule_type_commonCode = db.relationship("CommonCode",
order_by="CommonCode.SortOrder",
foreign_keys=[rule_type])
source_commonCode = db.relationship("CommonCode",
order_by="CommonCode.SortOrder",
foreign_keys=[source])
def __init__(self):
return
def __repr__(self):
return '<Rules_CNC %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
del d['rule_type_commonCode']
d['type_name'] = self.rule_type_commonCode.EXT1 if self.rule_type_commonCode is not None else ""
del d['source_commonCode']
d['source_name'] = self.source_commonCode.EXT1 if self.rule_type_commonCode is not None else ""
d['source_code'] = self.source_commonCode.Code if self.rule_type_commonCode is not None else ""
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d")
return d
@property
def search_tag_list(self):
if (self.search_tag is not None):
return self.search_tag.split(',')
else:
return ''
class Rules_BlackList(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_BlackList'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
mal_file_name = db.Column(db.String(2000))
md5 = db.Column(db.String(1000), nullable=False)
size = db.Column(db.BigInteger)
description = db.Column(db.String(2000))
analysis_device = db.Column(db.String(200))
analysis_result = db.Column(db.String(200))
detection_source = db.Column(db.String(200))
source = db.Column(db.BigInteger, db.ForeignKey(CommonCode.idx))
uri = db.Column(db.String(2000))
rule_name = db.Column(db.String(255))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
del_yn = db.Column(db.String(1), default='N')
source_commonCode = db.relationship("CommonCode",
order_by="CommonCode.SortOrder",
foreign_keys=[source])
def __init__(self):
return
def __repr__(self):
return '<Rules_BlackList %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
del d['source_commonCode']
d['source_name'] = self.source_commonCode.EXT1
d['source_code'] = self.source_commonCode.Code
d['cre_dt'] = self.cre_dt.strftime(
"%Y-%m-%d %H:%M:%S"
) #New requirement hour, min, second format added
return d
class Data_Element(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Data_Element'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
column_name = db.Column(db.String(100), nullable=False, unique=True)
data_source = db.Column(db.String(100), nullable=False)
format = db.Column(db.String(100), nullable=False)
form = db.Column(db.String(100), nullable=False)
size = db.Column(db.Integer, nullable=True)
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
mod_dt = db.Column(db.DateTime)
use_yn = db.Column(db.String(1), default='Y')
del_yn = db.Column(db.String(1), default='N')
def __init__(self, id):
self.id = id
def __init__(self):
return
def __repr__(self):
return '<id %r>' % self.id
def serialize(self):
d = Serializer.serialize(self)
d['cre_dt'] = self.cre_dt.strftime(
"%Y-%m-%d %H:%M:%S") if self.cre_dt is not None else ''
d['mod_dt'] = self.mod_dt.strftime(
"%Y-%m-%d %H:%M:%S") if self.mod_dt is not None else ''
return d
def getLinkDataType(self):
if self.format == "number" and self.form == "time_seriese":
return ["list", None]
elif self.format == "string" and self.form == "single":
return ["single", None]
elif self.format == "string" and self.form == "list":
return ["map", None]
elif self.format == "string" and self.form == "map":
return ["map", None]
elif self.format == "number" and self.form == "array":
return ["single_list", self.size]
elif self.format == "number" and self.form == "single":
return ["single", self.size]
class Rules_FileAnalysis(db.Model, Serializer):
__table_args__ = {"schema": "GSP_WEB"}
__tablename__ = 'Rules_FileAnalysis'
# region parameter input
seq = db.Column(db.Integer, primary_key=True, autoincrement=True)
orgfilename = db.Column(db.String(1000), nullable=False)
realfilename = db.Column(db.String(1000), nullable=False)
subpath = db.Column(db.String(1000), nullable=False)
description = db.Column(db.String(2000))
cre_id = db.Column(db.String(100))
cre_dt = db.Column(db.DateTime, default=datetime.datetime.now())
mod_dt =db.Column(db.DateTime, default=datetime.datetime.now())
del_yn = db.Column(db.String(1), default='N')
def __init__(self ):
return
def __repr__(self):
return '<Rules_FileAnalysis %r>' % (self.seq)
def serialize(self):
d = Serializer.serialize(self)
d['cre_dt'] = self.cre_dt.strftime("%Y-%m-%d")
return d
