def shorten():
conn = UrlDatabase()
if request.method == 'POST':
try:
url = request.get_json()['URL']
if not validators.url(url):
raise ValueError('Invalid Url format')
result = conn.check(url)
if result:
return result['ShortUrl']
# code for short url
code = shortuuid.ShortUUID().random(length=8)
# prevent code collision
while conn.collection.find_one({'UrlCode': code}):
code = shortuuid.ShortUUID().random(length=8)
short_url = f"{config['general']['BaseUrl']}:{config['general']['Port']}/{code}"
conn.insert(url, short_url, code)
return short_url
except Exception as e:
logging.exception('POST data format not correct')
return 'POST data format not correct'
else:
return 'Method not supported'
def generate_merchant_passkey(phone):
if (db.session.query(StoresModel).filter(
StoresModel.phone_number == phone).count() == 0):
passkey = shortuuid.ShortUUID().random(length=10)
storeID = shortuuid.ShortUUID(alphabet="0123456789").random(length=5)
try:
data = StoresModel(None, None, None, phone, passkey, False,
storeID)
data.save
return jsonify({
"success": True,
"passkey": passkey,
"phone": phone
})
except Exception as e:
return (
jsonify({
"success": False,
"error": "Failed to generate passkey : " + str(e),
}),
500,
)
else:
return jsonify({
"success": False,
"error": "Merchant already has a passkey generated !"
})
def POST(self, ignored):
v = web.input()
if 'content0' in v:
output = "<html><body>THESE URLS CAN ONLY BE LOADED ONCE!<br><dl><dd>Content</dd><dt>URL</dt>"
content = v['c0']
ct = 0
while len(content) > 0:
if ('nc' + ct) not in v or v['nc' + ct] != 1:
try:
content = json.dumps(json.loads(content))
except:
try:
content = json.dumps(yaml.load(content))
if content.find('"') == 0:
content = content[1:-1]
except:
pass
secret_key = shortuuid.ShortUUID().random(length=16)
cipher = AES.new(secret_key, AES.MODE_ECB)
content_key = shortuuid.ShortUUID().random(length=16)
f = open(os.environ['FILE_DIR'] + content_key, 'w')
content += ' ' * (16 - (len(content) % 16))
f.write(base64.b64encode(cipher.encrypt(content)))
f.close()
output += "<dd>" + content[
0:16] + "</dd><dt>https://" + os.environ[
'DOMAIN'] + "/" + content_key + "~" + secret_key + "</dt>"
content = ''
ct += 1
if 'content' + str(ct) in v:
content = v['content' + str(ct)]
return output
else:
raise web.seeother('/')
def start_new_session(self):
tmp_uuid = shortuuid.ShortUUID().random(length=6).upper()
while self._check_if_id_is_unique(tmp_uuid) == False:
tmp_uuid = shortuuid.ShortUUID().random(length=6)
else:
self.session_uuid = tmp_uuid
logging.info(f"Create new session with uuid: {self.session_uuid}")
self.session_path: Path = self.base_dir.joinpath(self.session_uuid)
self.session_path.mkdir()
self.main_window.new_session(str(self.session_path))
def test_submit_video(driver):
login(driver)
print("Going to the expert interface...")
expert_interface_btn = driver.find_element_by_id('expert_interface')
expert_interface_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'video-left')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'video-right')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
# print("Skipping tutorial")
# skip_tutorial_btn = driver.find_element_by_id('start_comparing_button')
# skip_tutorial_btn.click()
vid1 = shortuuid.ShortUUID().random(length=10)
vid2 = shortuuid.ShortUUID().random(length=10)
def set_video(which, vid_id):
selector = driver.find_element_by_id(which)
c = selector.find_element_by_class_name('video_id_text_field')
c = c.find_elements_by_tag_name('input')[0]
c.clear()
c.send_keys(vid_id)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
set_video('video-left', vid1)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
set_video('video-right', vid2)
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
expert_submit_btn = driver.find_element_by_id('expert_submit_btn')
expert_submit_btn.click()
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_no_pending_expert')))
WebDriverWait(driver, TIME_WAIT).until(
EC.presence_of_element_located((By.ID, 'id_submitted_text_info')))
assert do_api_call_v2(driver,
url=f"/videos/?video_id={vid1}")['count'] >= 1
assert do_api_call_v2(driver,
url=f"/videos/?video_id={vid2}")['count'] >= 1
logout(driver)
def userkey_getorset():
if g.user.userkey is None:
newuserkey = shortuuid.ShortUUID().random(length=22)
checkunique = User.query.filter_by(userkey=newuserkey).first()
if not checkunique is None:
newuserkey = shortuuid.ShortUUID().random(length=22)
u = User.query.filter_by(id=g.user.id).first()
if not u is None:
u.userkey = newuserkey
db.session.commit()
return newuserkey
else:
return g.user.userkey
def generate_uid():
"""
Method to generate a unique survey id.
:return: ``Survey.SURVEY_UID_LEN`` letters long unique id.
"""
survey_uid = shortuuid.ShortUUID().random(
length=Survey.SURVEY_UID_LEN).lower()
while Survey.objects.filter(survey_uid=survey_uid).exists():
survey_uid = shortuuid.ShortUUID().random(
length=Survey.SURVEY_UID_LEN).lower()
return survey_uid
def post(self, request, pk):
namelist = list(filter(lambda x: x, map(lambda x: x.strip(), request.POST['list'].split('\n'))))
user_id = 1
contest = Contest.objects.get(pk=pk)
for name in namelist:
if name.startswith('*'):
comment = name[1:].strip()
star = True
else:
comment = name
star = False
password_gen = shortuuid.ShortUUID("23456789ABCDEF")
password = password_gen.random(8)
while True:
try:
username = self._get_username(pk, user_id)
email = '*****@*****.**' % username
user = User.objects.create(username=username, email=email)
user.set_password(password)
user.save()
user.avatar.save('generated.png', Identicon(user.email).get_bytes())
ContestParticipant.objects.create(user=user, comment=comment, hidden_comment=password,
star=star, contest=contest)
break
except IntegrityError:
pass
user_id += 1
invalidate_contest(contest)
return HttpResponseRedirect(request.POST['next'])
async def test(url: UrlSchema):
url = dict(url)
if (url["customCode"]):
shortCode = url["customCode"]
else:
shortCode = shortuuid.ShortUUID().random(length=8)
shortUrl = os.path.join(config("BASE_URL"), shortCode)
urlExists = Url.objects(shortCode=shortCode)
if len(urlExists) != 0:
raise HTTPException(status_code=400,
detail="Short code is invalid, It has been used.")
try:
url = Url(longUrl=url["longUrl"],
shortCode=shortCode,
shortUrl=shortUrl)
url.save()
return {
"message": "Successfully shortened URL.",
"shortUrl": shortUrl,
"longUrl": url["longUrl"]
}
except Exception as e:
print(e)
raise HTTPException(status_code=500,
detail="An unknown error occurred.")
def post(self, request):
try:
url = request.POST.get('url')
except Exception as ex:
return JsonResponse({'error': ex}, status=400)
try:
url_object = URL.objects.filter(http_url=url)
if url_object:
url_object = URL.objects.get(http_url=url)
print("Existing URL object found", url_object.created,
type(url_object.created))
if is_valid_url(url_object.created):
print("URL object not expired")
pass
else:
print("Object is expired, extending expiry time")
import datetime
url_object.created = datetime.datetime.now()
url_object.save()
else:
print("Create new URL object")
url_object = URL.objects.create(
short_url=settings.SITE_URL + "/" +
shortuuid.ShortUUID().random(length=6),
http_url=url)
except Exception as ex:
return JsonResponse({'error': ex}, status=500)
serializer = ShortURLSerializer(url_object)
return Response(serializer.data)
def insert_function(cursor, conn, d, today):
logging.info("start insert_function.")
logging.info('insert_function:开始插入数据,共插入' + str(len(d)) + '条数据')
tableName = 'DATAPREDICT_DISTRIBUTION_INFO'
path = os.path.realpath(sys.argv[0])
createName = getConf("common", "createName", path)
createId = getConf("common", "createId", path)
modifyName = getConf("common", "modifyName", path)
modifyId = getConf("common", "modifyId", path)
for i in range(
len(d)
): # ['Issue_Region_Code4','Issue_Region_Name','num','qws','time']
try:
sqlInsert = "insert into " + tableName + "(OID,ISSUE_REGION_CODE,ISSUE_REGION_NAME,FORECAST_NUM,ISSUE_REGION_FLAG,FORECAST_DATE,CREATE_DATE,CREATOR_NAME,CREATOR_ID,MODIFY_DATE,MODIFY_NAME,MODIFY_ID) VALUES ('%s', '%s', '%s', %s, %s, date('%s'), timestamp('%s'),'%s','%s', timestamp('%s'),'%s','%s')" % (
str(shortuuid.ShortUUID().random(length=20)), d.iloc[i, 0],
d.iloc[i, 1], d.iloc[i, 2], d.iloc[i, 3], d.iloc[i, 4],
str(today), createName, createId, str(today), modifyName,
modifyId)
print sqlInsert
cursor.execute(sqlInsert)
logging.info('insert_function:成功插入' + str(i + 1) + '条数据')
except Exception as e:
logging.error("insert_function: %s\t" % (e))
conn.rollback() # 回滚
def wav_to_mp3():
if 'wav' not in request.files:
abort(400, description='file is not attached')
data = request.form.to_dict()
wav_file = request.files['wav']
wav_data = BytesIO(wav_file.read())
audio = AudioSegment.from_wav(wav_data)
if data.get('silence', False):
silence_ms = int(float(data.get('silence')) * 1000)
audio += AudioSegment.silent(duration=silence_ms)
mp3_params = _mp3_parameters(data)
output_data = BytesIO()
r = audio.export(output_data,
format="mp3",
codec="libmp3lame",
**mp3_params)
if not r:
abort(400, description='failed wave to mp3')
name = shortuuid.ShortUUID().random(length=8)
output_data.seek(0)
return send_file(output_data,
as_attachment=True,
attachment_filename=f'{name}.mp3',
mimetype='audio/mpeg')
class Reply(db.Model):
__tablename__ = 'reply'
id = db.Column(db.String(64),
default=shortuuid.ShortUUID().random(length=24),
primary_key=True)
content = db.Column(db.Text)
topic_id = db.Column(db.String(64), db.ForeignKey('topic.id'))
author_id = db.Column(db.String(64), db.ForeignKey('user.id'))
reply_id = db.Column(db.String(64), db.ForeignKey('reply.id'))
create_at = db.Column(db.DateTime, default=datetime.datetime.now())
ups = db.relationship('User',
secondary=ups,
backref=db.backref('ups', lazy='dynamic'),
lazy='dynamic')
messages = db.relationship('Message', backref='reply', lazy='dynamic')
@property
def serialize(self):
return {
'id': self.id,
'author': self.author.author_serialize,
'content': self.content,
'create_at': self.create_at,
'reply_id': self.reply_id,
'is_uped': False,
'ups': [i.id for i in self.ups],
}
def __repr__(self):
return '<Reply %r>' % self.id
def copy(self, **kwargs):
"""
Provide a deep copy of itself for use in branches
https://docs.djangoproject.com/en/1.7/topics/db/queries/#copying-model-instances
If new related objects created (other than default), inherit this class.
!!!! This is going to need review based on the unique surl attributes. !!!!!
!!!! This is NOT tested. !!!!!
"""
shrtn.set_alphabet(settings.SURL_ALPHABET)
while True:
# the surl must be unique and the likelihood of clash is low, so try again
try:
self.surl = shrtn.ShortUUID().random(
length=settings.SURL_LENGTH)
self.pk = None
self.id = None
self.save()
except IntegrityError:
continue
else:
break
self.creator = kwargs.get("creator", self.creator)
self.creator_ip = kwargs.get("creator_ip", self.creator_ip)
self.save()
return self
def make_cert_common_name_unique(apps, schema_editor):
# Loading concrete model is required here otherwise "renew" won't work
Cert = load_model('django_x509', 'Cert')
VpnClient = get_swapped_model(apps, 'config', 'VpnClient')
for cert in Cert.objects.iterator():
qs = Cert.objects.filter(
common_name=cert.common_name, organization_id=cert.organization_id
).exclude(pk=cert.pk)
for dupe_cn_cert in qs.iterator():
try:
vpn_client = (
VpnClient.objects.select_related('config', 'config__device')
.only('config__device__name', 'config__device__mac_address')
.get(cert_id=dupe_cn_cert.id)
)
common_name = (
f'{vpn_client.config.device.mac_address}'
'-{vpn_client.config.device_name}'
)
except VpnClient.DoesNotExist:
pass
common_name = dupe_cn_cert.common_name[:58]
unique_slug = shortuuid.ShortUUID().random(length=8)
common_name = f'{common_name}-{unique_slug}'
dupe_cn_cert.common_name = common_name
# in some older versions `serial_number` can be None
# in this case we'll assign a serial number while renewing
if dupe_cn_cert.serial_number is None:
dupe_cn_cert.serial_number = uuid4().int
dupe_cn_cert.renew()
def _parse_sentence_tokens(self, token_list):
# TODO possibly add auto-(de)capitalization to answers
""" Markup rules:
<> - Task wrapper.
Contents may include:
| - delimiter for possible answers, e.g. He <will|is going to> play basketball tomorrow
() - input placeholder, e.g. She <is(be)> ready
"""
for t in token_list:
if t.startswith("<") and t.endswith(">"):
_raw_task = t[1:-1]
task_id = str(shortuuid.ShortUUID().random(length=10))
try:
placeholder = re.findall(r"\(.*?\)", _raw_task)[0][1:-1]
except IndexError:
placeholder = None
answer_options = re.sub(r"\(.*?\)", "", _raw_task).split("|")
self.answer_keys[task_id] = answer_options
token = {
"type": "kb_input",
"task_id": task_id,
"placeholder": placeholder,
}
else:
token = {"type": "plaintext", "text": t}
yield token
def sendOneTimeText(request):
try:
phone = request.data['phoneNumber']
# Generates a unique id
u_id = shortuuid.ShortUUID().random(length=7)
# Check the database for the users unique id with a value of not verified
user = User.objects.get(phoneNumber=phone)
db_text = OneTimeText.objects.filter(userId=user, stillValid=True)
# If there is an entry of not verified - we change the status
if db_text:
db_text[0].stillValid = False
db_text[0].save()
# Store the uniqued id in the db
un_text = OneTimeText(userId=user, oneTimeValue=u_id, stillValid=True)
un_text.save()
# Send a text message to the user containing the unique id
client = Client(SECRET_SID, AUTH_TOKEN)
message = client.messages.create(
messaging_service_sid='MG57180d14384644fee5935dc3733225e2',
body=f'Your one time key - {str(u_id)}',
to=f'+1{phone}')
return Response({'success': True, 'msg': 'Successfully sent a text!'})
except:
return Response({'success': False, 'msg': 'Something went wrong...'})
def do_reply(topic_id):
accesstoken = request.form.get('accesstoken', '')
content = request.form.get('content', '')
reply_id = request.form.get('reply_id', '')
user = User.get_by_accesstoken(accesstoken)
if not user:
return bad_request('无效的token')
topic = Topic.query.filter(Topic.id == topic_id).first()
if not topic:
return bad_request('话题不存在')
if not content:
return forbidden('回复内容不能为空')
parent_reply = Reply.query.filter(Reply.id == reply_id).first()
reply = Reply()
reply.id = shortuuid.ShortUUID().random(length=24)
reply.author = user
reply.content = markdown.markdown(link_users(content))
reply.topic = topic
if parent_reply:
reply.parent = parent_reply
user.score += 5
topic.last_reply_at = datetime.datetime.now()
topic.reply_count += 1
db.session.add_all([user, topic, reply])
db.session.commit()
Message.send_message(
search_users(content), topic_id, reply.id,
parent_reply.author_id if parent_reply else topic.author_id)
return jsonify({'success': True, 'reply_id': reply.id})
def any_to_mp3():
if 'file' not in request.files:
abort(400, description='file is not attached')
data = request.form.to_dict()
file = request.files['file']
file_data = BytesIO(file.read())
if os.path.splitext(file.filename)[1] == '.wav':
audio = AudioSegment.from_wav(file_data)
elif os.path.splitext(file.filename)[1] == '.mp3':
audio = AudioSegment.from_mp3(file_data)
else:
abort(400, description='unsupported file format')
if data.get('silence', False):
silence_ms = int(float(data.get('silence')) * 1000)
audio += AudioSegment.silent(duration=silence_ms)
mp3_params = _mp3_parameters(data)
output_data = BytesIO()
r = audio.export(output_data,
format='mp3',
codec='libmp3lame',
**mp3_params)
if not r:
abort(400, description='failed wave to mp3')
name = shortuuid.ShortUUID().random(length=8)
output_data.seek(0)
return send_file(output_data,
as_attachment=True,
attachment_filename=f'{name}.mp3',
mimetype='audio/mpeg')
def get(self, request):
uid = str(request.user.id)
uid_key = int(shortuuid.ShortUUID(alphabet="123456789").random(length=9))
qr_uid_key = int('{:1d}{:9d}'.format(2, uid_key))
res = WeixinService.create_qrcode(
{
"expire_seconds": settings.QRCODE_BIND_TOKEN_EXPIRE_TIME,
"action_name": "QR_SCENE",
"action_info": {
"scene": {
"scene_id": qr_uid_key
}
}
}
)
ticket = WeixinService.show_qrcode(
res['ticket']
)
cache.set(
uid_key,
uid,
settings.QRCODE_BIND_TOKEN_EXPIRE_TIME
)
return HttpResponse(ticket, mimetype="image/jpeg")
def issue(self, **kwargs):
"""
Issue a token for sending.
:param kwargs:
:return:
"""
shrtn.set_alphabet(settings.SURL_ALPHABET)
while True:
# the surl must be unique and the likelihood of clash is low, so try again
try:
self.surl = shrtn.ShortUUID().random(
length=settings.TOKEN_SURL_LENGTH)
self.save()
except IntegrityError:
continue
else:
break
self.creator = kwargs["creator"]
self.creator_ip = kwargs.get("creator_ip", None)
self.novel = kwargs["novel"]
self.recipient = kwargs["recipient"]
self.is_purchased = kwargs.get("is_purchased", False)
self.charge = kwargs.get("charge", None)
self.price = kwargs.get("price", Decimal("0.00"))
# if purchased, and the creator and recipient are the same, then the person is buying this themselves
# (i.e.) not a gift - and the book is being automatically sent...
if kwargs["creator"] and kwargs.get(
"is_purchased",
False) and kwargs["creator"].email == kwargs["recipient"]:
self.is_valid = False
self.redeemer = kwargs["creator"]
self.redeemer_ip = kwargs.get("creator_ip", None)
self.redeemed_on = pytz.UTC.localize(datetime.now())
self.save()
def save(self):
if not hasattr(self, 'created_at'):
self.created_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
if not hasattr(self, 'ticket_url'):
self.ticket_url = 'http://localhost:5000/' + \
shortuuid.ShortUUID().random(length=6)
# Persist to db
FeatureRequestModel = self.FeatureRequestModel
# If self._id exists it should update existing feature request, else create new feature request
# Update existing feature request
if hasattr(self, '_id'):
feature_request = FeatureRequestModel.find_by_id(self._id)
self.modified_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
feature_request['title'] = self.title
# @todo only assing if exist!
if hasattr(self, 'description'):
feature_request['description'] = self.description
if hasattr(self, 'client_name'):
feature_request['client_name'] = self.client_name
if hasattr(self, 'client_priority'):
feature_request['client_priority'] = self.client_priority
if hasattr(self, 'target_date'):
feature_request['target_date'] = self.target_date
if hasattr(self, 'product_area'):
feature_request['product_area'] = self.product_area
if hasattr(self, 'agent_name'):
feature_request['agent_name'] = self.agent_name
feature_request['modified_at'] = self.modified_at
feature_request.save()
# Create new existing feature request
else:
feature_request = FeatureRequestModel({
'title': self.title,
'description': self.description,
'client_name': self.client_name,
'client_priority': self.client_priority,
'target_date': self.target_date,
'product_area': self.product_area,
'agent_name': self.agent_name,
'ticket_url': self.ticket_url
})
feature_request.save()
self._id = str(feature_request['_id'])
# Return dict representation including id assigned from db
self._reassign_client_priorities(feature_request)
saved_feature_request = {
'_id': self._id,
'title': self.title,
'description': self.description,
'client_name': self.client_name,
'client_priority': self.client_priority,
'target_date': self.target_date,
'created_at': self.created_at,
'product_area': self.product_area,
'agent_name': self.agent_name,
'ticket_url': self.ticket_url
}
if hasattr(self, 'modified_at'):
saved_feature_request['modified_at'] = self.modified_at
return saved_feature_request
def __init__(self,Name=None,cellNumber=None,email=None, type=None, address=None):
self.userID = shortuuid.ShortUUID().random(length=10)
self.Name = Name
self.cellNumber = cellNumber
self.email = email
self.type = type
self.address = address
def __init__(self, from_user, questions_text):
self.id = shortuuid.ShortUUID().random(length=5)
self.from_user = from_user
self.status = 'Открыт'
self.questions_text = questions_text
self.questions_answer = ''
self.responsible = 0
def _create(contest, comments):
random_gen = shortuuid.ShortUUID()
ContestInvitation.objects.bulk_create([
ContestInvitation(contest=contest,
code=random_gen.random(12),
comment=comment) for comment in comments
])
def save_model(self, request, obj, form, change):
# If is a new user, then randomly generate a password for them.
# To log into their account, they will need to use Forgot Password.
if not change:
password = shortuuid.ShortUUID().random(length=14)
obj.password = bcrypt.hashpw(password, bcrypt.gensalt())
super(UserAdmin, self).save_model(request, obj, form, change)
def generate_filename(batch, org_name=None):
uuid = shortuuid.ShortUUID()
if batch:
return uuid.uuid()
else:
file_name = org_name.strip() + "_" + uuid.uuid()
return file_name
def register_user(username, password):
#Ensure the username is available
if get_uuid(username) != constants.USERNAME_NOT_FOUND:
return "Username unavailable"
#Get the users.json file
json = get_json_file(constants.USERS_FILE_NAME)
#Hash and salt the password
password_hash = hash_password(password)
#Generate a random UUID with 8 characters
uuid = shortuuid.ShortUUID().random(length=8)
#Save the user object with their username and hash
json.append({
"uuid": uuid,
"username": username,
"password_hash": password_hash
})
#Add the user to the master user file
update_json_file(constants.USERS_FILE_NAME, json)
#Generate the user's event log file
event_file = []
update_json_file(constants.EVENTS_DIR_NAME + uuid + '.json', event_file)
return "Registration complete"
def updateOpinionWord(cursor, newWords, rowAll):
try:
newWords = newWords[:-1] #截取从头开始到倒数第三个字符之前
arr = newWords.split(",")
# 创建人信息
path = os.path.realpath(sys.argv[0])
createName = getConf("common", "createName", path)
createId = getConf("common", "createId", path)
for ai in arr:
# 查询新的ISSUE_REGION_NAME
sql = "SELECT ISSUE_REGION_NAME FROM ORGANIZATION_SET where ISSUE_REGION_CODE like '" + rowAll.get(
"ISSUE_REGION_CODE") + "%'"
cursor.execute(sql)
rowsWp = cursor.fetchall()
if (rowsWp != []):
petition_dfWp = pd.DataFrame(rowsWp)
petition_dfWp.columns = ['ISSUE_REGION_NAME']
# print petition_dfWp
ISSUE_REGION_NAME = petition_dfWp.iat[0, 0]
# print ISSUE_REGION_NAME
# 插入新词
aiArr = ai.split(" ")
uuid = shortuuid.ShortUUID().random(length=20)
data = str(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(time.time())))
# time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
sql= "INSERT INTO DATAPREDICT_OPINION_WORD (OID, NEW_WORD, WORD_FREQUENCY, WORD_PART,CREATE_DATE, CREATOR_NAME, CREATOR_ID, MODIFY_DATE, MODIFY_NAME, MODIFY_ID,ISSUE_REGION_FLAG,REGION_CODE,REGION_NAME,ISSUE_REGION_CODE,ISSUE_REGION_NAME,PETITION_BASIC_INFO_OID) " \
"VALUES ('%s', '%s', %s, '%s','%s', '%s', '%s','%s', '%s', '%s', %s, '%s','%s', '%s', '%s', '%s');" \
% (uuid,aiArr[0],aiArr[2],aiArr[1],data,createName,createId,data,'','',int(rowAll.get("ISSUE_REGION_FLAG")),rowAll.get("REGION_CODE"),rowAll.get("REGION_NAME"),rowAll.get("ISSUE_REGION_CODE"),ISSUE_REGION_NAME,rowAll.get("PETITION_BASIC_INFO_OID"))
# logging.info(sql)
cursor.execute(sql)
except Exception, ex:
logging.error("updateOpinionWord Failed : %s\t" % (ex))
def resources_create(request):
if request.method == "POST":
form = ResourceForm(request.POST)
if form.is_valid():
resource = form.save(commit=False)
resource.company = request.user.profile.company
resource.slug = slugify(form.cleaned_data["title"])
resource.slug += "-" + shortuuid.ShortUUID(
"abcdefghijkmlnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
).random(length=12)
resource.lead = request.user
resource.save()
for tag_text in form.cleaned_data["tags"].split(","):
if tag_text.strip():
tag, created = Tag.objects.get_or_create(text=slugify(tag_text))
TagResource.objects.get_or_create(tag=tag, resource=resource)
CompanyTag.objects.get_or_create(
company=request.user.profile.company, tag=tag
)
return redirect("main:resources_view", resource.slug)
else:
messages.error(request, "Document creation failed")
return redirect("main:resources")
else:
form = ResourceForm()
return render(request, "main/resources_create.html", {"form": form})
