def __init__(self, domain_id, get=None, post=None):
self.domain_id = BaseFied(value=domain_id, error=None)
self.get = get or {}
self.post = post or {}
self.valid = True
self.initialize()
def init(self):
instance = DomainAttr.objects.filter(
domain_id=0, type="system", item=u'cf_moving_default').first()
value = {}
if instance:
try:
value = json.loads(instance.value)
except:
value = {}
if not isinstance(value, dict):
value = {}
if self.post:
value["src_server"] = self.post.get("src_server", "")
value["src_mailbox"] = self.post.get("src_mailbox", "")
value["src_password"] = self.post.get("src_password", "")
value["ssl"] = str(self.post.get("ssl", "-1"))
src_mailbox = value.get("src_mailbox", "{ACCOUNT}")
src_mailbox = "{ACCOUNT}" if not src_mailbox else src_mailbox
src_password = value.get("src_password", "{PASSWORD}")
src_password = "******" if not src_password else src_password
self.value = value
self.src_server = BaseFied(value=value.get("src_server", ""),
error=None)
self.src_mailbox = BaseFied(value=src_mailbox, error=None)
self.src_password = BaseFied(value=src_password, error=None)
self.ssl = BaseFied(value=value.get("ssl", "-1"), error=None)
def initialize(self):
self.initBasicParams()
newData = self.post if self.post else self.get
if "domain_id" in newData:
self.domain_id = BaseFied(value=newData["domain_id"], error=None)
try:
oldData = json.loads(self.cf_domain_signature.value)
except:
oldData = {}
oldData = {} if not isinstance(oldData, dict) else oldData
self.content_html = oldData.get(u"html", u"")
if self.content_html and u"new" in oldData:
self.content_html = base64.decodestring(self.content_html)
self.content_text = oldData.get(u"text", u"")
if newData:
self.content_html = newData.get(u"content_html", u"")
self.content_text = newData.get(u"content_text", u"-1")
saveData = {
u"html":
get_unicode(base64.encodestring(get_string(self.content_html))),
u"text":
self.content_text,
u"new":
u"1", #针对老版本的兼容标记
}
self.cf_domain_signature = BaseFied(value=json.dumps(saveData),
error=None)
def initialize(self):
self.initBasicParams()
newData = self.post if self.post else self.get
if "domain_id" in newData:
self.domain_id = BaseFied(value=newData["domain_id"], error=None)
try:
oldData = json.loads(self.cf_pwd_rule.value)
except:
oldData = {}
oldData = {} if not isinstance(oldData, dict) else oldData
for name, param in self.PRAAM_RULE_VALUE.items():
default = self.PARAM_RULE_LIMIT[param]
setattr(self, name, oldData.get(param, default))
if newData:
for key, default in self.PARAM_LIST.items():
value = self.formatOptionValue(key, newData.get(key, u"-1"))
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
for name, param in self.PRAAM_RULE_VALUE.items():
setattr(self, name, newData.get(param, u"-1"))
saveData = {}
for name, param in self.PRAAM_RULE_VALUE.items():
saveData[param] = getattr(self, name)
self.cf_pwd_rule = BaseFied(value=json.dumps(saveData), error=None)
def initialize(self):
self.initBasicParams()
newData = self.post if self.post else self.get
if "domain_id" in newData:
self.domain_id = BaseFied(value=newData["domain_id"], error=None)
try:
oldCleanData = json.loads(self.cf_spaceclean.value)
except:
oldCleanData = {}
try:
oldMailData = json.loads(self.cf_spacemail.value)
except:
oldMailData = {}
oldCleanData = {} if not isinstance(oldCleanData,
dict) else oldCleanData
oldMailData = {} if not isinstance(oldMailData, dict) else oldMailData
self.general_keep_time = get_unicode(
oldCleanData.get(u"general_keep_time", u"0"))
self.sent_keep_time = get_unicode(
oldCleanData.get(u"sent_keep_time", u"0"))
self.spam_keep_time = get_unicode(
oldCleanData.get(u"spam_keep_time", u"0"))
self.trash_keep_time = get_unicode(
oldCleanData.get(u"trash_keep_time", u"0"))
self.subject = oldMailData.get(u"subject", u"")
self.content = oldMailData.get(u"content", u"")
self.warn_rate = get_unicode(oldMailData.get(u"warn_rate", u"85"))
if newData:
self.general_keep_time = get_unicode(
newData.get(u"general_keep_time", u"0"))
self.sent_keep_time = get_unicode(
newData.get(u"sent_keep_time", u"0"))
self.spam_keep_time = get_unicode(
newData.get(u"spam_keep_time", u"0"))
self.trash_keep_time = get_unicode(
newData.get(u"trash_keep_time", u"0"))
self.subject = newData.get(u"subject", u"")
self.content = newData.get(u"content", u"")
self.warn_rate = get_unicode(newData.get(u"warn_rate", u"85"))
saveCleanData = {
u"general_keep_time": self.general_keep_time,
u"sent_keep_time": self.sent_keep_time,
u"spam_keep_time": self.spam_keep_time,
u"trash_keep_time": self.trash_keep_time,
}
saveMailData = {
u"subject": self.subject,
u"content": self.content,
u"warn_rate": self.warn_rate,
}
self.cf_spaceclean = BaseFied(value=json.dumps(saveCleanData),
error=None)
self.cf_spacemail = BaseFied(value=json.dumps(saveMailData),
error=None)
def __init__(self, instance=None, get=None, post=None):
self.domain_id = BaseFied(value=0, error=None)
self.instance = instance
self.get = get or {}
self.post = post or {}
self.__initialize()
self.__valid = True
def __setparam(self):
data = self.post if self.post else self.get
for key, default in self.PARAM_LIST.items():
if data:
obj = BaseFied(value=data.get(key, default), error=None)
elif self.instance:
obj = BaseFied(value=getattr(self.instance, key), error=None)
else:
obj = BaseFied(value=default, error=None)
setattr(self, key, obj)
def __initialize(self):
if self.post or (self.get and not self.instance):
self.__setparam()
elif self.instance:
self.ip = BaseFied(value=self.instance.ip, error=None)
self.name = BaseFied(value=self.instance.name, error=None)
self.disabled = BaseFied(value=str(self.instance.disabled),
error=None)
else:
self.__setparam()
def initPostParamsDefaultNone(self):
data = self.post if self.post else self.get
if "domain_id" in data:
self.domain_id = BaseFied(value=data["domain_id"], error=None)
for key, default in self.PARAM_LIST.items():
if not key in data:
continue
value = self.formatOptionValue(key, data[key])
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
def __initialize(self):
default = self.PARAM_DEFAULT
if self.instance:
self.domain_id = BaseFied(value=self.instance.domain_id,
error=None)
value = json.loads(self.instance.value)
else:
value = copy.copy(default)
data = self.post if self.post else self.get
for k in default.keys():
if k in data:
value[k] = data[k]
elif not k in value:
value[k] = default[k]
if data:
domain_id = data.get("domain_id", 0)
self.domain_id = BaseFied(value=domain_id, error=None)
for k, v in value.iteritems():
self[k] = BaseFied(value=v, error=None)
self.value = BaseFied(value=value, error=None)
#sw_antispam、sw_antivirus的值保存在core_domain表中
instance = Domain.objects.filter(id=self.domain_id.value).first()
self.instance_domain = instance
if instance:
self.sw_sendlimit = BaseFied(value=instance.sendlimit, error=None)
else:
self.sw_sendlimit = BaseFied(value='-1', error=None)
if data:
self.sw_sendlimit = BaseFied(value=data.get("sw_sendlimit", '-1'),
error=None)
def initPostParamsDefaultDisable(self):
data = self.post if self.post else self.get
if "domain_id" in data:
self.domain_id = BaseFied(value=data["domain_id"], error=None)
data = self.post if self.post else self.get
if data:
self.domain_id = BaseFied(value=data["domain_id"], error=None)
for key, default in self.PARAM_LIST.items():
value = self.formatOptionValue(key, data.get(key, u"-1"))
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
def __initialize(self):
if self.instance:
value = json.loads(self.instance.value)
self.server = BaseFied(value=value.get("server", ""), error=None)
self.corp = BaseFied(value=value.get("corp", ""), error=None)
self.receiver = BaseFied(value=value.get("receiver", ""),
error=None)
self.open = BaseFied(value=str(value.get("open", "1")), error=None)
self.openApp = BaseFied(value=value.get("openApp", "MyApp"),
error=None)
self.loginurl = BaseFied(value=value.get("loginurl", ""),
error=None)
self.__setparam()
def __setparam(self):
data = self.post if self.post else self.get
for key, default in self.PARAM_LIST.items():
if data:
obj = BaseFied(value=data.get(key, default), error=None)
setattr(self, key, obj)
#设置默认值
if key == "token" and not self.instance1:
obj = BaseFied(value=default, error=None)
setattr(self, key, obj)
elif key == "open" and not self.instance2:
obj = BaseFied(value=default, error=None)
setattr(self, key, obj)
def initialize(self):
self.initBasicParams()
self.initPostParamsDefaultDisable()
data = self.post if self.post else self.get
#sw_userbwlist对应的是core_domain的userbwlist列，特殊处理之
if not data:
domainObj = Domain.objects.filter(id=self.domain_id.value).first()
sw_userbwlist = "-1" if not domainObj else domainObj.userbwlist
self.sw_userbwlist = BaseFied(value=get_unicode(sw_userbwlist),
error=None)
else:
self.sw_userbwlist = BaseFied(value=get_unicode(
data.get("sw_userbwlist", "-1")),
error=None)
def __setparam(self):
data = self.post if self.post else self.get
for key, default in self.PARAM_LIST.items():
if data:
obj = BaseFied(value=data.get(key, default), error=None)
setattr(self, key, obj)
#设置默认值
elif not self.instance:
if key == "loginurl":
obj_domain = Domain.objects.all().first()
if obj_domain:
default = u"http://mail.%s" % (obj_domain.domain)
obj = BaseFied(value=default, error=None)
setattr(self, key, obj)
def initialize(self):
self.initBasicParams()
self.initPostParams()
self.initStatus()
data = self.post if self.post else self.get
if not data:
domainDisabled = Domain.objects.filter(
id=self.domain_id.value).first()
domainDisabled = "1" if not domainDisabled else domainDisabled.disabled
self.domainDisabled = BaseFied(value=str(domainDisabled),
error=None)
else:
self.domainDisabled = BaseFied(value=str(
data.get("domainDisabled", "1")),
error=None)
def __initialize(self):
if self.instance:
value = json.loads(self.instance.value)
self.server = BaseFied(value=value.get("server", ""), error=None)
self.username = BaseFied(value=value.get("username", ""),
error=None)
self.password = BaseFied(value=value.get("password", ""),
error=None)
self.open = BaseFied(value=str(value.get("open", "1")), error=None)
self.loginurl = BaseFied(value=value.get("loginurl", ""),
error=None)
self.__setparam()
def initStatus(self):
statMailbox = Mailbox.objects.filter(
domain_id=self.domain_id.value).aggregate(
size__count=Count('id'),
size__msum=Sum('quota_mailbox'),
size__nsum=Sum('quota_netdisk'))
mailboxUsed = statMailbox["size__count"]
spaceUsed = statMailbox["size__msum"]
netdiskUsed = statMailbox["size__nsum"]
aliasUsed = len(
CoreAlias.objects.filter(domain_id=self.domain_id.value).all())
self.mailboxUsed = BaseFied(value=mailboxUsed, error=None)
self.aliasUsed = BaseFied(value=aliasUsed, error=None)
self.spaceUsed = BaseFied(value=spaceUsed, error=None)
self.netdiskUsed = BaseFied(value=netdiskUsed, error=None)
def __setparam(self):
#清理掉前面的值
for name in self.PROTO_LIST2.keys():
if hasattr(self, name):
delattr(self, name)
data = self.post if self.post else self.get
for key, default in self.PARAM_LIST.items():
if data:
obj = BaseFied(value=data.get(key, default), error=None)
elif self.instance:
obj = BaseFied(value=getattr(self.instance, key), error=None)
else:
obj = BaseFied(value=default, error=None)
setattr(self, key, obj)
if data:
for name, value in self.PROTO_LIST2.items():
if name in data:
obj = BaseFied(value=value, error=None)
setattr(self, name, obj)
def initBasicParams(self):
for key, default in self.PARAM_LIST.items():
sys_type = self.PARAM_TYPE[key]
instance = DomainAttr.objects.filter(
domain_id=self.domain_id.value, type=sys_type,
item=key).first()
setattr(self, "instance_%s" % key, instance)
value = instance.value if instance else default
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
def initialize(self):
self.subject = u""
self.content = u""
self.initBasicParams()
newData = self.post if self.post else self.get
if "domain_id" in newData:
self.domain_id = BaseFied(value=newData["domain_id"], error=None)
try:
oldData = json.loads(self.cf_welcome_letter.value)
self.subject = oldData.get(u"subject", u"")
self.content = oldData.get(u"content", u"")
except:
oldData = {}
if newData:
self.subject = newData.get(u"subject", u"")
self.content = newData.get(u"content", u"")
saveData = json.dumps({
"subject": self.subject,
"content": self.content
})
self.cf_welcome_letter = BaseFied(value=saveData, error=None)
def initialize(self):
self.initBasicParams()
newData = self.post if self.post else self.get
if "domain_id" in newData:
self.domain_id = BaseFied(value=newData["domain_id"], error=None)
try:
oldData = json.loads(self.cf_personal_sign.value)
except:
oldData = {}
oldData = {} if not isinstance(oldData, dict) else oldData
for name, default in self.PARAM_LIST_DEFAULT.items():
setattr(self, name, oldData.get(name, default))
if self.personal_sign_templ:
self.personal_sign_templ = get_unicode(
base64.decodestring(get_string(self.personal_sign_templ)))
if newData:
self.personal_sign_new = get_unicode(
newData.get(u"personal_sign_new", u"-1"))
self.personal_sign_forward = get_unicode(
newData.get(u"personal_sign_forward", u"-1"))
self.personal_sign_auto = get_unicode(
newData.get(u"personal_sign_auto", u"-1"))
self.personal_sign_templ = get_unicode(
newData.get(u"content_html", u""))
saveData = {
u"personal_sign_new":
self.personal_sign_new,
u"personal_sign_forward":
self.personal_sign_forward,
u"personal_sign_auto":
self.personal_sign_auto,
u"personal_sign_templ":
get_unicode(
base64.encodestring(get_string(self.personal_sign_templ))),
}
self.cf_personal_sign = BaseFied(value=json.dumps(saveData),
error=None)
def initialize(self):
self.count = u"0"
self.timespan = u"0"
self.initBasicParams()
newData = self.post if self.post else self.get
if "domain_id" in newData:
self.domain_id = BaseFied(value=newData["domain_id"], error=None)
try:
oldData = json.loads(self.cf_def_safe_login.value)
self.count = oldData.get(u"count", u"0")
self.timespan = oldData.get(u"timespan", u"0")
except:
oldData = {}
if newData:
for key, default in self.PARAM_LIST.items():
value = self.formatOptionValue(key, newData.get(key, u"-1"))
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
self.count = newData.get(u"count", u"0")
self.timespan = newData.get(u"timespan", u"0")
saveData = json.dumps({"count": self.count, "timespan": self.timespan})
self.cf_def_safe_login = BaseFied(value=saveData, error=None)
def __initialize(self):
if self.post or (self.get and not self.instance):
self.__setparam()
elif self.instance:
self.ip = BaseFied(value=self.instance.ip, error=None)
self.name = BaseFied(value=self.instance.name, error=None)
self.update_time = BaseFied(value=self.instance.update_time,
error=None)
self.disabled = BaseFied(value=str(self.instance.disabled),
error=None)
expire_time = self.instance.expire_time
t_tuple = time.localtime(int(expire_time))
self.expire_time = BaseFied(value=time.strftime(
'%Y-%m-%d %H:%M:%S', t_tuple),
error=None)
else:
self.__setparam()
def __initialize(self):
data = {}
if self.post:
data = self.post
self.is_post = True
#短信服务器配置
confSms = DomainAttr.objects.filter(domain_id=0,
type="system",
item="cf_sms_conf").first()
dataSms = "{}" if not confSms else confSms.value
try:
jsonSms = json.loads(dataSms)
jsonSms = {} if not isinstance(jsonSms, dict) else jsonSms
except:
jsonSms = {}
self.sms_type = jsonSms.get(u"type", u"")
self.sms_account = jsonSms.get(u"account", u"")
self.sms_password = jsonSms.get(u"password", u"")
self.sms_sign = jsonSms.get(u"sign", u"")
if "sms_type" in data:
self.sms_type = data["sms_type"]
if "sms_account" in data:
self.sms_account = data["sms_account"]
if "sms_password" in data:
self.sms_password = data["sms_password"]
if "sms_sign" in data:
self.sms_sign = data["sms_sign"]
jsonSms["type"] = self.sms_type
jsonSms["account"] = self.sms_account
jsonSms["password"] = self.sms_password
jsonSms["sign"] = self.sms_sign
self.cf_sms_conf = BaseFied(value=json.dumps(jsonSms), error=None)
self.sms_cost = None
try:
if self.sms_account and self.sms_password:
self.sms_cost = sms_interface.query_sms_cost(
self.sms_type, self.sms_account, self.sms_password)
except Exception, err:
print err
class CustomKKserverForm(DotDict):
PARAM_LIST = dict((
(u'server', u''),
(u'corp', u'0001'),
(u'service', u''),
(u'open', u'1'),
(u'loginurl', u''),
))
def __init__(self, instance=None, get=None, post=None):
self.instance = instance
self.get = get or {}
self.post = post or {}
self.__initialize()
self.__valid = True
def __initialize(self):
if self.instance:
value = json.loads(self.instance.value)
self.server = BaseFied(value=value["server"], error=None)
self.corp = BaseFied(value=value["corp"], error=None)
self.service = BaseFied(value=value["service"], error=None)
self.open = BaseFied(value=str(value.get("open", "1")), error=None)
self.loginurl = BaseFied(value=value.get("loginurl", ""),
error=None)
self.__setparam()
def __setparam(self):
data = self.post if self.post else self.get
for key, default in self.PARAM_LIST.items():
if data:
obj = BaseFied(value=data.get(key, default), error=None)
setattr(self, key, obj)
#设置默认值
elif not self.instance:
if key == "loginurl":
obj_domain = Domain.objects.all().first()
if obj_domain:
default = u"http://mail.%s" % (obj_domain.domain)
obj = BaseFied(value=default, error=None)
setattr(self, key, obj)
def is_valid(self):
self.__check()
return self.__valid
def __check(self):
if not self.server.value.strip():
self.server.set_error(_(u"无效的服务器参数"))
self.__valid = False
return self.__valid
if not self.corp.value.strip():
self.corp.set_error(_(u"无效的corp参数"))
self.__valid = False
return self.__valid
if not self.service.value.strip():
self.service.set_error(_(u"无效的service参数"))
self.__valid = False
return self.__valid
if not self.loginurl.value.strip():
self.loginurl.set_error(_(u"无效的邮件查看地址"))
self.__valid = False
return self.__valid
return self.__valid
def save(self):
value = {
"server": self.server.value,
"corp": self.corp.value,
"service": self.service.value,
"loginurl": self.loginurl.value,
"open": self.open.value,
}
value = json.dumps(value)
DomainAttr.saveAttrObjValue(domain_id=0,
type="system",
item="sw_custom_kkserver_setting",
value=value)
clear_redis_cache()
def __check(self):
if not self.token.value.strip():
value = get_random_string(32)
self.token = BaseFied(value, error=None)
return self.__valid
class DomainSysRecvWhiteListForm(DotDict):
def __init__(self, domain_id, type=u"send", get=None, post=None):
self.type = type
self.domain_id = BaseFied(value=domain_id, error=None)
self.get = get or {}
self.post = post or {}
self.valid = True
self.initialize()
@property
def getSendLimitWhiteList(self):
lists = CoreWhitelist.objects.filter(type="send",
domain_id=self.domain_id.value,
mailbox_id=0).all()
num = 1
for d in lists:
yield num, d.id, d.email, str(d.disabled)
num += 1
@property
def getRecvLimitWhiteList(self):
lists = CoreWhitelist.objects.filter(type="recv",
domain_id=self.domain_id.value,
mailbox_id=0).all()
num = 1
for d in lists:
yield num, d.id, d.email, str(d.disabled)
num += 1
def initialize(self):
def getPostMailbox(key):
#从 entry_{{ mailbox }}_id 这种格式中把 mailbox 提取出来
l = key.split("_")
l.pop(0)
flag = l.pop(-1)
mailbox = "_".join(l)
return mailbox
def setPostMailboxData(mailbox, key, value):
self.mailboxDict.setdefault(mailbox, {})
self.mailboxDict[mailbox][key] = value
#enddef
self.newMailbox = u""
self.mailboxDict = {}
self.newMailboxList = []
data = self.post if self.post else self.get
if not data:
return
newMailbox = data.get("new_mailbox", u"")
newMailboxList = data.get("new_mailbox_list", u"")
if newMailbox:
self.newMailbox = newMailbox
boxList = newMailboxList.split("|")
boxList = [box for box in boxList if box.strip()]
if boxList:
self.newMailboxList = boxList
for k, v in data.items():
if k.startswith("{}_".format(self.type)):
if k.endswith("_id"):
mailbox = getPostMailbox(k)
setPostMailboxData(mailbox, "id", v)
elif k.endswith("_delete"):
mailbox = getPostMailbox(k)
setPostMailboxData(mailbox, "delete", v)
for mailbox in self.mailboxDict.keys():
isDisabled = data.get(u"{}_{}_disabled".format(self.type, mailbox),
u"1")
setPostMailboxData(mailbox, "disabled", isDisabled)
def is_valid(self):
if not self.domain_id.value:
self.valid = False
self.domain_id.set_error(_(u"无效的域名"))
return self.valid
self.check()
return self.valid
def check(self):
return self.valid
def checkSave(self):
if self.is_valid():
self.save()
def saveNewEmail(self, mailbox):
if mailbox in self.mailboxDict:
return
obj = CoreWhitelist.objects.create(type=self.type,
domain_id=self.domain_id.value,
mailbox_id=0,
email=mailbox)
obj.save()
def saveOldEmail(self):
for mailbox, data in self.mailboxDict.items():
data = self.mailboxDict[mailbox]
entry_id = data.get("id", "")
if not entry_id:
continue
obj = CoreWhitelist.objects.filter(id=entry_id).first()
if not obj:
continue
if data.get("delete", u"-1") == u"1":
obj.delete()
else:
obj.disabled = data.get("disabled", "-1")
obj.save()
def save(self):
#先添加新的邮箱
if self.newMailbox:
self.saveNewEmail(self.newMailbox)
for mailbox in self.newMailboxList:
self.saveNewEmail(mailbox)
self.saveOldEmail()
def __initialize(self):
if self.instance1:
self.token = BaseFied(value=self.instance1.value, error=None)
if self.instance2:
self.open = BaseFied(value=self.instance2.value, error=None)
self.__setparam()
class DomainForm(DotDict):
PARAM_LIST = {}
PARAM_TYPE = {}
def __init__(self, domain_id, get=None, post=None):
self.domain_id = BaseFied(value=domain_id, error=None)
self.get = get or {}
self.post = post or {}
self.valid = True
self.initialize()
def initialize(self):
self.initBasicParams()
self.initPostParams()
def formatOptionValue(self, key, value):
if value.lower() == u"on":
return u"1"
return value
def initBasicParams(self):
for key, default in self.PARAM_LIST.items():
sys_type = self.PARAM_TYPE[key]
instance = DomainAttr.objects.filter(
domain_id=self.domain_id.value, type=sys_type,
item=key).first()
setattr(self, "instance_%s" % key, instance)
value = instance.value if instance else default
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
def initPostParams(self):
self.initPostParamsDefaultNone()
def initPostParamsDefaultNone(self):
data = self.post if self.post else self.get
if "domain_id" in data:
self.domain_id = BaseFied(value=data["domain_id"], error=None)
for key, default in self.PARAM_LIST.items():
if not key in data:
continue
value = self.formatOptionValue(key, data[key])
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
def initPostParamsDefaultDisable(self):
data = self.post if self.post else self.get
if "domain_id" in data:
self.domain_id = BaseFied(value=data["domain_id"], error=None)
data = self.post if self.post else self.get
if data:
self.domain_id = BaseFied(value=data["domain_id"], error=None)
for key, default in self.PARAM_LIST.items():
value = self.formatOptionValue(key, data.get(key, u"-1"))
obj = BaseFied(value=value, error=None)
setattr(self, key, obj)
def is_valid(self):
if not self.domain_id.value:
self.valid = False
self.domain_id.set_error(_(u"无效的域名"))
return self.valid
self.check()
return self.valid
def check(self):
return self.valid
def checkSave(self):
if self.is_valid():
self.save()
def paramSave(self):
for key in self.PARAM_LIST.keys():
obj = getattr(self, "instance_%s" % key, None)
value = getattr(self, key).value
if obj:
sys_type = self.PARAM_TYPE[key]
obj.domain_id = u"{}".format(self.domain_id.value)
obj.type = u"{}".format(sys_type)
obj.item = u"{}".format(key)
obj.value = u"{}".format(value)
obj.save()
else:
sys_type = self.PARAM_TYPE[key]
DomainAttr.objects.create(domain_id=u"{}".format(
self.domain_id.value),
type=u"{}".format(sys_type),
item=u"{}".format(key),
value=u"{}".format(value))
clear_redis_cache()
def save(self):
self.paramSave()
