def __init__(self):
self.sources = [
model.Page('mako', model.Image(os.path.join(IMAGE_DIR,
'mako.png'))),
model.Page('Haaretz הארץ',
model.Image(os.path.join(IMAGE_DIR, 'haaretz.png'))),
model.Page('חדשות 10',
model.Image(os.path.join(IMAGE_DIR, '10.png'))),
model.Page('וואלה! תרבות ובידור',
model.Image(os.path.join(IMAGE_DIR, 'walla.png'))),
model.Page('ynet', model.Image(os.path.join(IMAGE_DIR,
'ynet.jpg')))
]
def post(self):
"""Post method is the only method"""
firmid = self.request.get('firmid')
projid = self.request.get('projid')
name = self.request.get('name')
is_front_picture = self.request.get('is_front_picture') == 'yes'
proj_key = ndb.Key('Firm', firmid, 'Project', projid)
proj = proj_key.get()
small_bi = self.get_uploads('small_img')[0]
large_bi = self.get_uploads('large_img')[0]
image = model.Image(parent=proj_key, id=name)
image.name = name
image.is_front = is_front_picture
image.small_mime_type = small_bi.content_type
image.small_blob_key = small_bi.key()
image.large_mime_type = large_bi.content_type
image.large_blob_key = large_bi.key()
image.put()
if is_front_picture:
proj.front_picture_id = image.name
proj.front_picture_url = image.to_dict()['small_url']
proj.put()
pass
self.response.headers['Content-Type'] = 'text/html'
html = globals.jinja_env.get_template(
'admin/image_status.html').render({
'firmid': firmid,
'projid': projid,
'imgid': 'short_name',
})
self.response.out.write(html)
def image(self, **args): args = self.clean_args(args) img = self.getImage(args) d = model.Image() buffer = d.getImagePath(img) cherrypy.response.headers['Content-Type'] = 'image/jpg' return buffer.getvalue()
def generate(self, user, date):
(a, b), c = getRandomGossip()
news_outlet = choice(self.sources)
post = model.Post(date, a, model.Image(c), news_outlet, None)
comment = model.Comment(b, user, post)
post.comments.append(comment)
return post
def execute(self):
method = self.request.method
user = self.values['user']
if method == 'GET': #Request identifies actions
action = self.get_param('act')
url_path = self.get_param('url')
query = model.Image.gql('WHERE url_path=:1', url_path)
image = query.get()
if not image:
self.render_json({
'saved': False,
'msg': self.getLocale('Not found')
})
elif user.nickname != image.author_nickname and user.rol != 'admin':
self.render_json({
'saved': False,
'msg': self.getLocale('Not allowed')
})
elif action == 'del': #delete image
image.delete()
self.render_json({'saved': True})
else:
self.render_json({'saved': False})
else: #File upload
# Get the uploaded file from request.
upload = self.request.get("upload")
nick = user.nickname
dt = datetime.datetime.now()
prnt = dt.strftime("%Y%m%d%H%M%S")
url_path = nick + "/" + prnt
try:
query = model.Image.all(keys_only=True).filter(
'url_path', url_path)
entity = query.get()
if entity:
raise Exception(
'unique_property must have a unique value!')
image = model.Image(author=user,
author_nickname=nick,
thumbnail=upload,
url_path=url_path)
image.put()
self.values["label"] = self.getLocale(
"Uploaded as: %s") % url_path
except:
self.values["label"] = self.getLocale('Error saving image')
self.render("/translator-util.html")
return
def add_image_to_db(session, filename, artist_name, title):
image = model.Image()
image.filename = filename
image.artist_name = artist_name
image.title = title
db_session.add(image)
db_session.commit()
def __generate_initial_content(self):
print('Generating content')
main_user_photo = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'saar.jpg'))
main_user = model.User('Saar Raz', main_user_photo,
model.User.GENDER_MALE)
main_user_photo = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'saar.jpg'))
photo0 = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'matan.jpg'))
friend = model.User('Matan Raviv', photo0, model.User.GENDER_MALE)
model.friends.append(friend)
photo1 = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'uria.jpg'))
friend = model.User('Uria Shaul-Mandel', photo1,
model.User.GENDER_MALE)
model.friends.append(friend)
photo2 = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'dvir.jpg'))
friend = model.User('Dvir Mordechai-Navot', photo2,
model.User.GENDER_MALE)
model.friends.append(friend)
photo2 = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'angela.jpg'))
friend = model.User('Angela Merkel', photo2, model.User.GENDER_MALE)
friend.birthday = datetime.datetime.today()
model.friends.append(friend)
photo2 = model.Image(
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'bar.jpg'))
friend = model.User('Bar Rafaeli', photo2, model.User.GENDER_MALE)
friend.birthday = datetime.datetime.today()
model.friends.append(friend)
for i in range(2000):
gender = random.choice(
[model.User.GENDER_FEMALE, model.User.GENDER_MALE])
model.random_people.append(
model.User(
random_name.generate_name(
gender == model.User.GENDER_MALE),
random_name.generate_pic(gender == model.User.GENDER_MALE),
gender))
model.User.set_main_user(main_user)
for i in range(15):
self.post(
random.choice(self._bots).generate(
random.choice(model.friends),
datetime.datetime.now() - datetime.timedelta(
seconds=random.random() *
datetime.timedelta(days=1).total_seconds())))
threading.Thread(target=self.periodically).start()
def save_blob_to_image_obj(blob_key, user_obj, img_type):
if user_obj:
user_key = user_obj.key
serving_url = images.get_serving_url(blob_key)
img = model.Image(user=user_key,
serving_url=serving_url,
blob_key=blob_key,
img_type=img_type)
img.put()
return serving_url
def __init__(self, access_token):
self.access_token = access_token
self._last_birthday_determination_time = None
self._bots = [
EnglishFakeNewsBot(),
RandomUserPostBot(),
HebrewFakeNewsBot()
]
self.batman = model.User(
'Batman',
model.Image(os.path.join(model.IMAGE_DIR, 'profile',
'batman.jpg')), model.User.GENDER_MALE)
self.__generate_initial_content()
def post(self):
res = entities.check_token(request.headers["Authorization"])
if res == None:
raise Exception("invalid token")
user, group = res
if group != entities.group_student:
uuid = user
else:
stu_obj = model.Student.query.filter_by(username=user).first()
uuid = stu_obj.project.uuid
parser = reqparse.RequestParser()
parser.add_argument(
"file",
type=werkzeug.datastructures.FileStorage,
location="files",
required=True,
)
parser.add_argument("type", required=True)
args = parser.parse_args()
f = args["file"]
fn = f.filename
if entities.filename_validation(fn) == False:
return err.upload_error
fn = entities.make_unique(fn)
fn = werkzeug.utils.secure_filename(fn)
folder = os.path.join(
os.path.abspath(__file__ + "/.."),
"../..",
entities.config.upload_path,
uuid,
)
if not os.path.exists(folder):
os.mkdir(folder)
path = os.path.join(folder, fn)
f.save(path)
fn = os.path.join(entities.config.url_prefix, f"./{uuid}/", fn)
db_f = None
if args["type"] == "file":
db_f = model.File(location=fn)
elif args["type"] == "image":
db_f = model.Image(path=fn, description="")
else:
raise Exception("Type not define")
model.db.session.add(db_f)
model.db.session.commit()
return {"status": "success", "link": fn}
def generate(self, user, when):
if random.random() < 0.1:
driver = webdriver.Chrome(r'chromedriver')
driver.get('https://tomforth.co.uk/guardiancomments/')
comment = driver.find_element_by_class_name('commentBody')
comment = Translator().translate(comment.text, dest='he').text
driver.close()
return model.Post(when, comment, None, user, None)
else:
image = requests.get(
requests.get('http://inspirobot.me/'
'api?generate=true').content).content
path = os.path.join(
model.IMAGE_DIR, 'generated',
'{}.jpg'.format(str(random.randint(0, 0xffffffff))))
open(path, 'wb').write(image)
return model.Post(
when,
random.choice(self.IMAGE_COMMENTS).format(
good_day=random.choice(self.GOOD_DAY)), model.Image(path),
user, None)
def _handle_image(self, data, playlist_id):
result = {'status': 'OK', 'images': {}}
if self._is_valid_image(data) == False:
result['status'] = 'No valid image at that URL.'
return result
image = model.Image()
image.user = self.get_current_user()
image.session = self.get_current_session()
self.db_session.add(image)
playlist = self.db_session.query(model.Playlist).get(playlist_id)
playlist.image = image
self.db_session.commit()
original_image = Image.open(data)
cropped_image = self._crop_to_square(original_image)
image.original = self._save_image(image.id, original_image.format,
original_image)
image.medium = self._save_image(image.id, original_image.format,
self._resize(cropped_image, 160))
self.db_session.commit()
def on_upload_image(self, path: str) -> model.Image:
return model.Image(path)
def fetch_img(feed_slug, eid, force=False):
"""
获取图片
"""
logging.info('task.fetch_image:entry id->%s ' % (str(eid)))
db = m.Session()
feed = db.query(m.Feed).filter_by(slug=feed_slug).first()
if feed is not None and not feed.fetch_image:
db.close()
return
entry = db.query(m.Entry).filter_by(id=eid).first()
if entry is None or (entry.got_img and not force):
logging.warning(
'entry not found , entry id->%s \n'
'or encounter error when I try fetch image for it last time.' %
(eid))
db.close()
return
img_serial = 0
total_size = 0
matches = list(PICTURE_RE.finditer(entry.content, re.I))
if matches and not path.exists(
path.join(config.img_storage_path, str(entry.id))):
os.mkdir(path.join(config.img_storage_path, str(entry.id)))
for match in matches:
if match.group(2).strip().lower() == 'gif':
extend, media_type = '.gif', 'image/gif'
elif match.group(2).strip().lower() == 'png':
extend, media_type = '.png', 'image/png'
else:
extend, media_type = '.jpg', 'image/jpeg'
file_name = md5(feed_slug + str(entry.id) +
str(img_serial)).hexdigest()
with open(
path.join(config.img_storage_path, str(entry.id),
file_name + extend), 'wb') as f:
try:
resopne = urlopen(match.group(1))
except Exception, e:
logging.warning("encounter exception %s" % (str(e)))
continue
if resopne.getcode() != 200:
logging.warning(
"response status %s \n Can not fetch img from src: %s",
response.status, match.group(1))
continue
f.write(resopne.read())
#endwith
total_size += path.getsize(
path.join(config.img_storage_path, str(entry.id),
file_name + extend))
img = m.Image(eid=entry.id,
serial_no=img_serial,
file_name=file_name,
extend=extend)
db.add(img)
img_serial += 1
if total_size >= config.img_size_per_entry:
logging.warning('entry %s contain too much image size: %sM%sK' %
(eid, total_size / 1024 / 1024, total_size % 1024))
break
for user in users_list:
subscriber = choice(users_list)
creator = choice(users_list)
if subscriber != creator:
crud.create_following(subscriber, creator)
else:
continue
u1 = choice(users_list)
u2 = choice(users_list)
i1 = model.Image(image_path="path string1",
description="ABCD",
date_posted=datetime.now(),
user=u1)
i2 = model.Image(image_path="pathstring2",
description="EFGH",
date_posted=datetime.now(),
user=u2)
images_in_db = [i1, i2]
model.db.session.add(i1, i2)
model.db.session.commit()
'''Assigning a reaction number to an image.'''
for _ in range(5):
random_image = choice(images_in_db)
reaction = randint(
1, 5
) #similar to rating format, each reaction number will represent img/like
