def addImage(mime, description, bf, name):
'Add Image'
image = Images(mime=mime, description=description, bf=bf, name=name)
image.size = len(image.bf)
image.filetype, image.width, image.height = getImageInfo(bf)
image.put()
return image
def post(self):
data = request.get_json()
try:
user_id = data['user_id']
name = data['name']
sex = data['sex']
filename = data['filename']
b64image = data['b64image']
decoded_image = base64.b64decode(b64image)
except Exception as e:
abort(400, e)
file_data = BytesIO(decoded_image)
file = FileStorage(file_data, filename=filename)
img_uri = os.path.join("static", BaseConfig.IMAGE_URI, filename)
file.save(img_uri)
new_image = Images(img_uri)
db.session.add(new_image)
try:
db.session.commit()
except Exception as e:
abort(500, e)
# PREDICTION
####
return jsonify()
def upload():
#---make static file if not exists
target = os.path.join(APP_ROOT, 'static/')
print(target)
if not os.path.isdir(target):
os.mkdir(target)
else:
print("Couldn't create upload directory {}".format(target))
#---get image
print(request.files.getlist("file"))
for upload in request.files.getlist("file"):
print(upload)
print("{} is the filename".format(upload.filename))
name = upload.filename
destination = "/".join([target, name])
print("Accept incoming file:", name)
print("Save it to:", destination)
upload.save(destination)
#---and store..
user_id = current_user.user_id
name = upload.filename
username = Users.query.filter_by(user_id=user_id).first().username
image = str('www.doc.gold.uk/usr/340/static/' + str(name))
new_image = Images(user_id=user_id,
username=username,
image=image,
name=name)
db.session.add(new_image)
db.session.commit()
#result = Images.query.filter_by(name=name).first()
return redirect(vs_url_for('add_image'))
return render_template('complete.html', name=name)
def add_image():
link = request.json["link"]
user_id = request.json["user_id"]
new_image = Images(link=link,user_id=user_id)
db.session.add(new_image)
db.session.commit()
return jsonify(success=True)
def add_image(request):
if 'token' in request.POST:
token = request.POST['token']
userdetail = UserDetail(request).getLoginUser()
user_id = userdetail['id']
data = {}
if 'file' in request.FILES:
image = request.FILES.get('file')
file_type = image.content_type.split('/')[0]
print "\n\n type of image : ", type(file_type)
if str(file_type) != "image":
data = {'is_valid': False, 'message': 'Please upload Images Only.'}
return HttpResponse(json.dumps(data))
try:
images = Images(user_id=user_id, image=request.FILES.get('file'))
images.save()
token = images.token
image_id = images.id
image_name = images.image_name
url = "http://" + request.META['HTTP_HOST'] + "/images/view/" + str(
token) + "/" + str(image_id)
data = {
'is_valid': True,
'name': image_name,
'url': url,
'token': token
}
except:
data = {'is_valid': False, 'message': 'Cannot Be Uploaded.'}
return HttpResponse(json.dumps(data))
def get_image_id(request):
# Get our desired filename.
uploading_filename = request.form.get("imageFileName")
if not uploading_filename:
return exceptions.BadRequest()
# Ensure we have an image.
if "jpegData" not in request.files:
return exceptions.BadRequest()
# An image ID has a maximum size of 7.
unique_id = generate_unique_id(Images, Images.image_id, 7)
if unique_id == "":
return exceptions.InternalServerError()
filename = f"{unique_id}.jpg"
# Next, save our file to disk.
jpeg_image = request.files["jpegData"]
jpeg_image.save(determine_path(current_order.order_id, filename))
# Finally, save state to the database.
added_image = Images(image_id=unique_id,
order_id=current_order.order_id,
filename=filename)
db.session.add(added_image)
db.session.commit()
return {
"imageID": unique_id,
}
def upload_file(id=""):
JSON = {}
if request.method == 'POST':
files = request.files.getlist('upload')
if files:
# load_photo(files, path_image, 768, path_thumbnail, 150)
filename = secure_filename(
utilites.transliterate(files[0].filename, "."))
input_image_folder = Config.full_images_folder + "/articles/" + str(
id) + "/"
if os.path.exists(input_image_folder):
files[0].save(input_image_folder + filename)
else:
os.mkdir(input_image_folder)
files[0].save(input_image_folder + filename)
path = "/articles/" + str(id) + "/" + filename
JSON["fileName"] = filename
JSON["uploaded"] = 1
JSON["url"] = Config.images_folder + path
image = Images(filename, path, "", utilites.timeNow("u"), id)
db.session.add(image)
db.session.commit()
JSON = json.dumps(JSON, ensure_ascii=True, indent=None, sort_keys=False)
return JSON, {'Content-Type': 'text/json'}
def setUp(self):
self.engine = create_engine('mysql+pymysql://')
self.session = Session(engine)
Base.metadata.create_all(self.engine)
self.characters_instance = Characters(1009610, "Spider-Man")
self.session.add(self.character_instance)
self.comics_instance = Comics(30885, "Age of Heroes (Trade Paperback)")
self.session.add(self.comics_instance)
self.creators_instance = Creators(9799, "David Baldeon")
self.session.add(self.creators_instance)
self.events_instance = Events(116, "Acts of Vengeance!")
self.session.add(self.events_instance)
self.series_instance = Series(10235, "Age of Heroes (2011)")
self.session.add(self.series_instance)
self.stories_instance = Stories(483, "Interior #483")
self.session.add(self.stories_instance)
self.images_instance = Images(
1, 0, "http://i.annihil.us/u/prod/marvel/i/mg/3/40/4c06c8261544e")
self.session.add(self.images_instance)
self.session.commit()
def home(request):
posts = Blog.objects.all()[:10]
for post in posts:
html = django_markdown.utils.markdown(value=post.body)
soup = BeautifulSoup(html)
try:
ex = soup.p.string
imgs = soup.findAll('img', {'src': True})
if len(imgs) > 1:
post.type = 4
for img in imgs:
url = img['src']
imglist = Images.objects.filter(link=url)
if len(imglist) == 0:
image = Images(link=url)
image.save()
else:
image = imglist[0]
post.imagelinks.add(image)
post.save()
post.excerpt = ex[0:330] + '...'
post.save()
except:
pass
return render_to_response('alwaysblue/index.html', {
'tags': Tag.objects.all(),
'posts': posts
})
def get_image_id(request):
# Get our desired filename.
uploading_filename = request.form.get("imageFileName")
if not uploading_filename:
return exceptions.BadRequest()
# Ensure we have an image.
if "jpegData" not in request.files:
return exceptions.BadRequest()
# Sanitize for when we write to disk.
filename = secure_filename(uploading_filename)
# Necessary as render templates require the original filename with ".jpg" appended.
# Nobody here is fond of this.
filename += ".jpg"
# An image ID has a maximum size of 7.
unique_id = generate_unique_id(Images, Images.image_id, 7)
if unique_id == "":
return exceptions.InternalServerError()
# Next, save our file to disk.
jpeg_image = request.files["jpegData"]
jpeg_image.save(determine_path(current_order.order_id, filename))
# Finally, save state to the database.
added_image = Images(
image_id=unique_id, order_id=current_order.order_id, filename=filename
)
db.session.add(added_image)
db.session.commit()
return {
"imageID": unique_id,
}
def edit_photos():
upload = FileForm()
set_loop = Set.query.order_by(Set.id.desc()).all()
if upload.validate_on_submit():
for loop in set_loop:
if request.form["select_set"] == loop.tag:
file = request.files['file']
bucket.put_object(Key='Tractor Show/' + loop.name + '/' +
file.filename,
Body=file)
newFile = Images(name=file.filename, set=loop)
db.session.add(newFile)
db.session.commit()
return redirect('/dashboard/photos#' + loop.tag)
add_set = AddSet()
if add_set.validate_on_submit():
render_tag = tag_generator(request.form["set"])
new_set = Set(name=request.form["set"], tag=render_tag)
db.session.add(new_set)
db.session.commit()
return redirect(url_for('edit_photos'))
return render_template('authentication/edit-photos.html',
upload=upload,
add_set=add_set,
set_loop=set_loop,
s3projects=s3projects)
def xmlparse():
#pagecode = urllib.urlopen("http://www.esmadrid.com/opendata/alojamientos_v1_es.xml")
pagecode = urllib.urlopen(
"http://cursosweb.github.io/etc/alojamientos_es.xml")
xmlsheet = pagecode.read()
noticias = xmlsheet.split("<service ")
for noticia in noticias[1:-1]:
url = noticia.split("<web>")[1].split("</web>")[0]
try:
alojamiento = Alojamientos.objects.get(url=url)
except Alojamientos.DoesNotExist:
name = noticia.split("<name><![CDATA[")[1].split("]]></name>")[0]
address = noticia.split("<address>")[1].split("</address>")[0]
zipcode = noticia.split("<zipcode>")[1].split("</zipcode>")[0]
country = noticia.split("<country>")[1].split("</country>")[0]
latitude = noticia.split("<latitude>")[1].split("</latitude>")[0]
longitude = noticia.split("<longitude>")[1].split(
"</longitude>")[0]
city = noticia.split("<subAdministrativeArea>")[1].split(
"</subAdministrativeArea>")[0]
alojamiento = Alojamientos(name=name,
url=url,
address=address,
zipcode=zipcode,
country=country,
latitude=latitude,
longitude=longitude,
city=city)
alojamiento.save()
images = noticia.split('<url>')
for image in images[1:6]:
image_url = image.split('</url>')[0]
image = Images(url=image_url, alojamiento=alojamiento)
image.save()
def addImage2(bf):
image = Images(bf=bf)
image.size = len(bf)
image.filetype, image.width, image.height = getImageInfo(bf)
if not image.filetype: return None
image.mime = image.filetype
image.put()
return image
def addImage(title, bf, referer):
'Add Image'
image = Images(description=title, bf=bf, referer=referer)
image.size = len(image.bf)
image.filetype, image.width, image.height = getImageInfo(bf)
if not image.filetype: return None
image.mime = image.filetype
image.put()
return image
def create_image_record(bucket, key):
'''
Creates an Image object to store in DB.
Record stored in Images table.
:param bucket: S3 bucket to use
:param key: path to image in specified S3 bucket
:returns: Images Object
'''
return Images(bucket=bucket, filename=PurePath(key).name, key=key)
def save_update_db(load_info):
latinput = load_info['lat_input']
lnginput = load_info['lng_input']
datepicker = load_info['datepicker']
tipo = load_info['tipo']
notes = load_info['notes']
print('entrou update', latinput, lnginput)
newsub = Submission(latinput=latinput,
lnginput=lnginput,
type_S=tipo,
temp=datepicker,
notes=notes)
db.session.add(newsub)
db.session.flush()
print('ppppp ', newsub, newsub.id)
file_urls = []
image_list = load_info['images']
for k, image in enumerate(image_list):
print(allowed_image(image.filename))
if allowed_image(image.filename):
ext = image.filename.rsplit(".", 1)[1]
new_filename = image.filename.rsplit(".", 1)[0] + '_sub' + str(
newsub.id) + '.' + ext
filename = photos.save(image, name=new_filename)
print('rrr', filename)
file_urls.append(photos.url(filename))
newfile = Images(sub=newsub,
img_data=image.read(),
img_name=new_filename,
stamp_save=date.today())
db.session.add(newfile)
print('aaaa ', newfile)
print(file_urls)
db.session.commit()
session['images_urls'] = file_urls
print('saved to database')
return 'Saved to database'
def get(self, request, *args, **kwargs):
conditions = dict(request.query_params)
for key, value in conditions.iteritems():
conditions[key] = conditions[key][0]
if "number_of_data" in conditions.keys():
number_of_data = conditions["number_of_data"][0]
conditions.pop('number_of_data', None)
images = MongoConnection.find_lastest_data("Images", conditions,
int(number_of_data))
else:
images = MongoConnection.find_data("Images", conditions=conditions)
serializer = serializers.ImageSerializer(
instance=[Images(**element) for element in images], many=True)
return Response(serializer.data)
def initdb_command():
db.create_all()
f = open("static/images.csv", "r")
for line in f:
images = [x.strip() for x in line.split(',')]
if (len(images) != 4):
continue
db.session.add(Images(images[0], images[1], images[2], images[3]))
db.session.commit()
print('Initialized the database.')
def gallery(request, imagename=None):
print imagename
if request.method == 'POST':
title = request.POST['pname']
img_data = request.POST['pdata']
p = Images(title=title, img_data=img_data)
p.save()
if request.method == 'GET':
image = Images.objects.filter(title=imagename)
for i in image:
data = i.img_data
print json.dumps(data)
t = get_template('paint.html')
html = t.render(Context({}))
if data:
html = """<script>var data=JSON.parse(' """ + data + """ ');</script>""" + html
else:
html = """<script>alert("Image not found")</script>""" + html
return HttpResponse(html)
def insert_default_entries(db):
# Create users
for name, email in DEFAULT_USERS_LIST:
hashed_password = generate_password_hash(DEFAULT_PASSWORD, method='sha256')
u = User(username=name, email=email, password=hashed_password)
db.session.add(u)
for node in COMPUTE_NODES:
default_status = COMPUTE_NODE_STATUS_DICT[0]
c = ComputeNode(ip_addr=node[0], compute_node_status=default_status, compute_node_wt=node[1])
db.session.add(c)
# Create Images
for i, (name, desc, wt) in enumerate(DEFAULT_IMAGES_LIST):
im = Images(image_name=name, image_wt=wt, description=desc)
db.session.add(im)
db.session.commit()
def get_upload_url():
# query param
filename = request.openapi.parameters.query['filename']
content_type = request.openapi.parameters.query['content-type']
# values used for S3 presigned-url
file_uuid = str(uuid.uuid4())
stem = path(filename).stem
# key is a PurePosixPath object so be mindful it's not a string
key = path(UPLOAD_FOLDER, file_uuid)
# key = f'{UPLOAD_FOLDER}/{file_uuid}'
try:
# upload image in database
image_record = Images(bucket=BUCKET_NAME,
filename=filename,
key=str(key))
db.session.add(image_record)
db.session.commit()
except DBAPIError as db_error:
print(f'DB API Error: {db_error.statement}')
raise
except SQLAlchemyError as alchemy_error:
print(f'SQL Alchemy Error: {alchemy_error}')
raise
# params for s3 put_object method
# tag + uuid
s3_params = {
'Bucket': BUCKET_NAME,
'Key': f'{key}',
'ContentType': content_type,
'Tagging': f'{stem}={file_uuid}'
}
url = s3.generate_presigned_url('put_object',
Params=s3_params,
HttpMethod="PUT",
ExpiresIn=10)
payload = {'presigned_url': url}
return jsonify(payload)
def initdb_command():
db.create_all()
paths = {
"filetofish.jpg": ["Yes, a filet-o-fish", "Image description here"],
"insomnia.jpg":
["Sugar We Are Going Down Swinging", "Image description here"],
"jesusisking.jpg": ["Jesus is King", "Image description here"],
"lite.jpg": ["Mr. Miller", "Image description here"],
"miley.jpg": ["Literally No One:", "Image description here"],
"pennstate.jpg": ["How Tough Are You?", "Image description here"],
"pizza.jpg": ["A Big Waste of Money", "Image description here"],
"pizza2.jpg": ["Where's the Ranch?", "Image description here"],
"pumpkin.jpg": ["Smashing Pumkpins", "Image description here"],
"rat.jpg": ["Oh Rats", "Image description here"],
}
for path in paths:
db.session.add(Images(path, paths[path][0], paths[path][1]))
db.session.commit()
print('Initialized the database.')
def upload_file():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit a empty part without filename
if file.filename == '':
flash('No selected file!')
return redirect(request.url)
if file and allowed_file(file.filename):
# Get secure filename
sec_fname = path.join(app.config['TEMP_FOLDER'],
secure_filename(file.filename))
file.save(sec_fname)
# Calculating MD5 hash and use it as filename
md5_hash = calc_md5(sec_fname)
save_dir = path.join(app.config['UPLOAD_FOLDER'], md5_hash[0:3])
if not path.exists(save_dir):
makedirs(save_dir)
# copy to new dir
save_path = path.join(save_dir, md5_hash)
shutil.copy2(sec_fname, save_path)
# remove temp
remove(sec_fname)
# Get resolution of image
im = Image.open(save_path)
im_type = 0 # default Image type
if im.format == 'JPEG':
im_type = 0
elif im.format == 'PNG':
im_type = 1
elif im.format == 'GIF':
im_type = 2
img = Images(md5_hash, im.size[1], im.size[0], im_type, g.user.id)
db.session.add(img)
db.session.commit()
# Image thumbnail
thumbs_dir = path.join(app.config['THUMBNAIL_FOLDER'],
md5_hash[0:3])
if not path.exists(thumbs_dir):
makedirs(thumbs_dir)
save_path = path.join(thumbs_dir, md5_hash)
try:
im.thumbnail((200, 200), Image.ANTIALIAS)
#print(im.size)
im.save(save_path, "JPEG")
except IOError:
print("cannot create thumbnail")
flash('File successfully uploaded. MD5: ' + md5_hash)
return redirect(url_for('index'))
return render_template('upload.html')
def unhash(request):
if request.method == 'POST':
photo = request.POST.get('photo')
hashcode = request.POST.get('hashcode')
encrypted = request.POST.get('encrypted')
#caption is added
caption = request.POST.get('caption')
list = encrypted.split("_")
print list
#storing the geo-tagged information in variables
lat = list[0]
long = list[1]
hr = list[2]
min = list[3]
day = list[4]
month = list[5]
yr = list[6]
hard_location = "Jagatpura, Jaipur Municipal Corporation, Jaipur, Rajasthan, 302033, India"
# forming the address and storing it in variable
list.pop(2)
list.pop(2)
list.pop(2)
list.pop(2)
list.pop(2)
try:
geolocator = Nominatim()
location = geolocator.reverse(list)
address = (location.address)
except:
address = hard_location
# saving the image in jpeg file
image = open("image.jpeg", "wb")
image.write(photo.decode('base64'))
image.close()
#generate the hash of the image
#hash = hashlib.md5()
hash = hashlib.sha256()
print hash
hash.update(open('image.jpeg', 'rb').read())
generated_hash = (hash.digest()).encode('base64')
user_obj = Images()
# saving into database
user_obj.hashcode = hashcode
user_obj.caption = caption
user_obj.latitude = lat
user_obj.longitude = long
user_obj.date = day
user_obj.month = month
user_obj.year = yr
user_obj.ocr = 1
user_obj.mse = 1
user_obj.pic.save('image.jpeg', File(open('image.jpeg')), save=False)
user_obj.location = address
user_obj.generated_hash = generated_hash
user_obj.save(force_insert=True)
#ocr = ocr_process('image.jpeg')
#mse = image_process('image.jpeg')
#user_obj.ocr = ocr
#user_obj.mse = mse
#user_obj.save()
##########
global new_name
new_name = str("image_" + str(user_obj.Uid) + ".jpeg")
os.rename("image.jpeg", new_name)
new_name2 = "image_" + str(user_obj.Uid)
new_name.encode('UTF-8')
#returning the user id of the data user submitted
print(user_obj.Uid)
try:
#thread.start_new_thread(return_Uid, ("Thread-1",user_obj.Uid,))
thread.start_new_thread(constraint_match, (
"Thread-2",
user_obj.Uid,
))
except Exception as e:
print(e)
return Response(user_obj.Uid)
def process_image():
'''
takes user input, create thumbnail, and store in DB
'''
uploadsDirExists = pathlib.Path('./uploads').exists()
thumbnailsDirExists = pathlib.Path('./thumbnails').exists()
if not uploadsDirExists:
pathlib.Path('./uploads').mkdir()
print("Uploads folder did not exist but was created.")
print("Add images to the Uploads folder and try again.")
return
if not thumbnailsDirExists:
pathlib.Path('./thumbnails').mkdir()
print("Thumbnails folder was created")
pics = list(pathlib.Path('./uploads').glob('*.*'))
size = (128, 128)
userFileName = input("Input image name: \n")
imgToProcess = 'noFile'
stem = 'noStem'
suffix = 'noSuffix'
for pic in pics:
if userFileName == pic.name:
imgToProcess = str(pic.name)
stem = str(pic.stem)
suffix = str(pic.suffix)
elif userFileName == pic.stem and pic.suffix:
imgToProcess = str(pic.name)
stem = str(pic.stem)
suffix = str(pic.suffix)
pathToImg = str(pathlib.Path('./uploads/{0}'.format(imgToProcess)))
thumbnailImg = '{0}.thumbnail{1}'.format(stem, suffix)
pathToOutput = str(pathlib.Path('./thumbnails/{0}'.format(thumbnailImg)))
try:
inThumbnails = pathlib.Path(pathToOutput).exists()
if inThumbnails:
print('Thumbnail already exists')
return
img = PIL.Image.open(pathToImg)
img.thumbnail(size)
img.save(pathToOutput, "JPEG")
print('Created: {0} of size{1}'.format(thumbnailImg, str(size)))
except FileNotFoundError:
print('Oops there was an error.')
print("File not found.")
return
except OSError:
print('Oops there was an error.')
print('Not an image file. Try again.')
return
except:
print('Unexpected error:', sys.exc_info()[0])
print('Check your configuration and try again.')
return
originalImage = Images(filename=imgToProcess,
thumbnailImg=thumbnailImg,
thumbnailPath=pathToOutput,
isThumbnail=False)
processedImage = Thumbnails(filename=thumbnailImg,
original=imgToProcess,
originalPath=pathToImg,
isThumbnail=True)
session.add_all([originalImage, processedImage])
session.commit()
def post(self):
branch_name = self.request.get('branch_name')
edit_type = self.request.get('e_type')
premise_type = self.request.get('p_type')
logging.info(self.request.POST)
picture_url_0 = self.request.get('picture_url_0')
if picture_url_0:
field_storage = self.request.POST.multi['picture_url_0']
mimetype = field_storage.type
logging.info("Mimetype: {}".format(mimetype))
user = self.current_user
branch_q = db.GqlQuery("SELECT * FROM Branch WHERE branch = :1",
branch_name)
branch = branch_q.get()
#branch = Branch(parent=branch_key('Business'))
#branch_key = branch.Key().id()
#b_key = db.Key.from_path('Branch', branch)
#tag_list1 = split(self.request.get('form_content_0'))
tag_list = ['one', 'two', 'three']
step = 0
if premise_type == "contention":
if edit_type == "0":
c = Contention(branch_key=branch, tags=tag_list)
c.content = self.request.get('form_content_0')
c.branch_name = branch_name
if self.logged_in:
logging.info('Checking currently logged in user')
logging.info(self.current_user.name)
sessiony = self.auth.get_user_by_session()
c.author = self.current_user.name
c.author_id = sessiony['user_id']
c.put()
if picture_url_0 != '':
i = Images(branch_key=branch, contention_key=c)
i.image = db.Blob(picture_url_0)
i.element_type = "contention"
i.description = self.request.get('image_description_0')
if self.logged_in:
i.author = self.current_user.name
i.author_id = sessiony['user_id']
i.put()
c.image_id = i.key().id()
c.put()
elif edit_type == "1":
contention_ID = self.request.get('c_id')
con = Contention.get_by_id(int(contention_ID))
if con.g_frames:
step = con.g_frames
else:
step = 0
gframe = Elements(contention_key=con,
element_type="contention",
gframe=step,
image_id=con.image_id,
author=con.author,
author_id=con.author_id,
content=con.content)
gframe.put()
con.content = self.request.get('form_content_0')
con.g_frames = step + 1
if picture_url_0 != '':
i = Images(branch_key=branch, contention_key=c)
i.image = db.Blob(picture_url_0)
i.element_type = "contention"
i.description = self.request.get('image_description_0')
if self.logged_in:
sessiony = self.auth.get_user_by_session()
i.author = self.current_user.name
i.author_id = sessiony['user_id']
i.put()
con.image_id = i.key().id()
con.put()
if premise_type == "element":
contention_ID = self.request.get('c_id')
con = Contention.get_by_id(int(contention_ID))
if edit_type == "0":
c = Elements(contention_key=con, gframe=step)
c.content = self.request.get('form_content_0')
c.branch_name = branch_name
if self.logged_in:
logging.info('Checking currently logged in user')
logging.info(self.current_user.name)
sessiony = self.auth.get_user_by_session()
c.author = self.current_user.name
c.author_id = sessiony['user_id']
c.put()
if picture_url_0 != '':
i = Images(branch_key=branch, contention_key=con)
i.image = db.Blob(picture_url_0)
i.element_type = "contention"
i.description = self.request.get('image_description_0')
if self.logged_in:
i.author = self.current_user.name
i.author_id = sessiony['user_id']
i.put()
c.image_id = i.key().id()
c.put()
con.g_frames = step + 1
con.put()
elif edit_type == "1":
contention_ID = self.request.get('c_id')
con = Contention.get_by_id(int(contention_ID))
gframe = Elements(contention_key=con,
element_type="contention",
gframe=step,
image_id=con.image_id,
author=con.author,
author_id=con.author_id,
content=con.content)
gframe.put()
con.content = self.request.get('form_content_0')
con.g_frames = step + 1
if picture_url_0 != '':
i = Images(branch_key=branch, contention_key=c)
i.image = db.Blob(picture_url_0)
i.element_type = "contention"
i.description = self.request.get('image_description_0')
if self.logged_in:
sessiony = self.auth.get_user_by_session()
i.author = self.current_user.name
i.author_id = sessiony['user_id']
i.put()
con.image_id = i.key().id()
con.put()
reasons = int(self.request.get('_reasons'))
objections = int(self.request.get('_objections'))
if reasons > 0:
if edit_type == "0":
for reas in range(1, reasons + 1):
pic = 'picture_url_' + str(reas)
pict = self.request.get(pic)
if premise_type == "contention":
r = Elements(contention_key=c,
top_level=1,
gframe=step)
if premise_type == "element":
r = Elements(contention_key=con,
top_level=0,
gframe=step,
parent_id=c.key().id())
r.element_type = 'reason'
if pict != '':
i = Images(branch_key=branch, contention_key=c)
i.image = db.Blob(picture_url_0)
i.element_type = "contention"
i.description = self.request.get('image_description_0')
if self.logged_in:
sessiony = self.auth.get_user_by_session()
i.author = self.current_user.name
i.author_id = sessiony['user_id']
i.put()
#r.image_id=i.key().id()
rcon = 'form_reason_' + str(reas)
r.content = self.request.get(rcon)
r.branch_name = branch_name
if self.logged_in:
sessiony = self.auth.get_user_by_session()
r.author = self.current_user.name
r.author_id = sessiony['user_id']
r.put()
elif edit_type == "1":
for reas in range(1, reasons + 1):
pic = 'picture_url_' + str(reas)
pict = self.request.get(pic)
el_id = 'form_reason_' + str(reas) + '_'
e_id = self.request.get(el_id)
rcon = 'form_reason_' + str(reas)
r_content = self.request.get(rcon)
logging.info("this is test")
logging.info('form_reason_' + str(reas) + '_')
r = Elements.get_by_id(int(e_id))
if r_content != r.content:
if premise_type == "contention":
gframe = Elements(contention_key=con,
element_type="reason",
gframe=step,
image_id=r.image_id,
author=r.author,
author_id=r.author_id,
content=r.content)
gframe.put()
r.content = r_content
r.g_frame = con.g_frames
if premise_type == "element":
r = Elements(contention_key=con,
parent_id=c.key().id())
r.top_level = 0
r.element_type = 'reason'
if pict != '':
i = Images(branch_key=branch, contention_key=c)
i.image = db.Blob(picture_url_0)
i.element_type = "contention"
i.description = self.request.get(
'image_description_0')
if self.logged_in:
sessiony = self.auth.get_user_by_session()
i.author = self.current_user.name
i.author_id = sessiony['user_id']
i.put()
#r.image_id=i.key().id()
rcon = 'form_reason_' + str(reas)
r.content = self.request.get(rcon)
r.branch_name = branch_name
if self.logged_in:
sessiony = self.auth.get_user_by_session()
r.author = self.current_user.name
r.author_id = sessiony['user_id']
r.put()
if objections > 0:
for objs in range(1, objections + 1):
picobjs = objs + 5
pic = 'picture_url_' + str(picobjs)
pict = self.request.get(pic)
o = Elements(contention_key=c)
if premise_type == "contention":
o = Elements(contention_key=c)
o.top_level = 1
if premise_type == "element":
o = Elements(contention_key=con, parent_id=c)
o.top_level = 0
if pict != '':
o.image = db.Blob(urlfetch.Fetch(pict).content)
ocon = 'form_objection_' + str(objs)
o.content = self.request.get(ocon)
o.branch_name = branch_name
if self.logged_in:
sessiony = self.auth.get_user_by_session()
o.author = self.current_user.name
o.author_id = sessiony['user_id']
o.put()
self.redirect('/conv?con_id=%s' % c.key().id())
def post(self):
data = request.get_json()
try:
#user_id = data['user_id']
name = data['name']
#sex = data['sex']
#img_filename = data['img_filename']
#b64image = data['b64image'] # for profile image!
b64video = data['b64video'] # for training images!
training = data['training']
#decoded_image = base64.b64decode(b64image)
decoded_video = base64.b64decode(b64video)
except Exception as e:
print(e)
abort(400, e)
#img_data = BytesIO(decoded_image)
video_data = BytesIO(decoded_video)
#user = User.query.filter_by(id=user_id).first()
seq_image_dir = "{}".format(name)
user_id = 1 # test...
seq_filename = "{}_{}.jpg".format(user_id,
get_filename_appended_date(""))
seq_image_dir = os.path.join("web", "static",
BaseConfig.SEQUENTIAL_IMAGE_URI,
seq_image_dir)
seq_image_uri = os.path.join(seq_image_dir, seq_filename)
file = FileStorage(video_data, filename=seq_filename)
mkdir(seq_image_dir)
file.save(seq_image_uri)
# add seq img db
new_seq_img = SequentialImages(seq_image_dir, 0)
db.session.add(new_seq_img)
try:
db.session.commit()
except Exception as e:
abort(500, e)
img_filename = "{}_{}.{}".format(user_id, secure_filename(""),
img_filename.split('.')[-1])
img_uri = os.path.join("static", BaseConfig.IMAGE_URI, img_filename)
file = FileStorage(img_data, filename=img_filename)
file.save(img_uri)
# add img db
new_img = Images(img_uri)
db.session.add(new_img)
try:
db.session.commit()
except Exception as e:
abort(500, e)
####
# read and video processing(opencv capture)... and save jpg img...
vidcap = cv2.VideoCapture(seq_filename)
success, image = vidcap.read()
count = 0
while success:
if count >= 60:
break
cv2.imwrite(os.path.join(seq_image_dir, "frame%d.jpg" % count),
image) # save frame as JPEG file
success, image = vidcap.read()
print('Read a new frame: ', success)
count += 1
####
# EXECUTE TRAINING
if training == 1:
print("training!")
####
# add family member db
'''
