def serie_nueva(request):
if request.method == "POST":
# UTILIZANDO formulario creado a mano
'''
form = SerieForm(request.POST)
if form.is_valid():
serie = Serie()
serie.titulo = form.cleaned_data["titulo"]
serie.slug = slugify.slugify(form.cleaned_data["titulo"])
serie.rating = 5.0
serie.save()
return HttpResponseRedirect(reverse("series_home")) # reverse es para ir al name del url.py
'''
# UTILIZANDO formulario generado desde el modelo
form = SerieForm3(request.POST)
if form.is_valid():
nueva_serie = form.save(commit = False)
nueva_serie.slug = slugify.slugify(nueva_serie.titulo)
nueva_serie.save()
return HttpResponseRedirect(reverse("series_home"))
else:
form = SerieForm3()
return render_to_response("series/serie_nueva.html", {"form": form,}, context_instance=RequestContext(request))
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if not name or not description:
self.error(400, "Bad Data: Name: %s, Description: %s" \
% (name, description))
return
slug = slugify.slugify(name)
existing_s = List.get_by_slug(slug)
if existing_s:
self.error(404, "A list with this name already exists")
return
l = List(name=name, slug=slug, description=description)
l.put()
invalidate_cache()
self.response.set_status(201)
self.json(l.rest(self.base_url(version)))
def post(self, version):
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
image = self.request.get('image', default_value=None)
level = self.request.get('level', default_value=None)
severity = Level.get_severity(level)
if name and description and severity and image:
slug = slugify.slugify(name)
status = Status.get_by_slug(slug)
# Update existing resource
if status:
status.description = description
status.severity = severity
status.image = image
status.name = name
status.put()
self.json(status.rest(self.base_url(version)))
# Create new service
else:
status = Status(name=name,
slug=slug,
description=description,
severity=severity,
image=image)
status.put()
self.json(status.rest(self.base_url(version)))
else:
self.error(400, "Bad Data")
else:
self.error(404, "API Version %s not supported" % version)
def create(self):
name = self.item.title
slug = slugify.slugify(name)
existing = MatchedFile.get_by_slug(slug)
if existing:
logging.debug("the file " + name + " already exists")
return False
url = None
content = None
if self.source.zipped == False and self.source.authorizationRequired == False:
url = self.item.url
else:
content = self.getContentForFile()
if content is None:
logging.warn("no content found when looking for " + name + ", no matching file will be created")
return False
url = settings.SITE_URL + MatchedFile.get_url_for_slug(slug) + "/content"
logging.info("Adding the new matched file " + name)
newFile = MatchedFile( name=name, slug=slug, date=datetime.now(), fileUrl=url, content=content,
source=self.source, series=self.show )
newFile.put()
return True
def post(self, version):
logging.debug("ServicesListHandler#post")
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
serviceurl = self.request.get('serviceurl', default_value=None)
pattern = self.request.get('pattern', default_value=None)
freq = self.request.get('freq', default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if existing_s:
existing_s.description = description
existing_s.serviceurl = serviceurl
existing_s.pattern = pattern
existing_s.freq = freq
existing_s.put()
self.json(existing_s.rest(self.base_url(version)))
# Create new service
else:
s = Service(name=name, slug=slug, description=description, serviceurl=serviceurl)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(400, "Bad Data: Name: %s, Description: %s" % (name, description))
else:
self.error(404, "API Version %s not supported" % version)
def save(self, *args, **kwargs):
if self.parent_category:
self.level = self.parent_category.level + 1
self.slug = slugify(self.name)
if not make_thumbnail(self.img, self.img_thumb):
raise Exception('Could not create thumbnail - is the file type valid?')
super().save(*args, **kwargs)
def post(self, version):
logging.debug("ServicesListHandler#post")
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if existing_s:
existing_s.description = description
existing_s.put()
self.json(existing_s.rest(self.base_url(version)))
# Create new service
else:
s = Service(name=name, slug=slug, description=description)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(
400, "Bad Data: Name: %s, Description: %s" %
(name, description))
else:
self.error(404, "API Version %s not supported" % version)
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if not name or not description:
self.error(400, "Bad Data: Name: %s, Description: %s" \
% (name, description))
return
slug = slugify.slugify(name)
existing_s = List.get_by_slug(slug)
if existing_s:
self.error(404, "A list with this name already exists")
return
l = List(name=name, slug=slug, description=description)
l.put()
invalidate_cache()
self.response.set_status(201)
self.json(l.rest(self.base_url(version)))
def create(self):
name = self.item.title
slug = slugify.slugify(name)
existing = MatchedFile.get_by_slug(slug)
if existing:
logging.debug("the file " + name + " already exists")
return False
url = None
content = None
if self.source.zipped == False and self.source.authorizationRequired == False:
url = self.item.url
else:
content = self.getContentForFile()
if content is None:
logging.warn("no content found when looking for " + name +
", no matching file will be created")
return False
url = settings.SITE_URL + MatchedFile.get_url_for_slug(
slug) + "/content"
logging.info("Adding the new matched file " + name)
newFile = MatchedFile(name=name,
slug=slug,
date=datetime.now(),
fileUrl=url,
content=content,
source=self.source,
series=self.show)
newFile.put()
return True
def post(self, version):
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
image = self.request.get('image', default_value=None)
level = self.request.get('level', default_value=None)
severity = Level.get_severity(level)
if name and description and severity and image:
slug = slugify.slugify(name)
status = Status.get_by_slug(slug)
# Update existing resource
if status:
status.description = description
status.severity = severity
status.image = image
status.name = name
status.put()
self.json(status.rest(self.base_url(version)))
# Create new service
else:
status = Status(name=name, slug=slug, description=description,
severity=severity, image=image)
status.put()
self.json(status.rest(self.base_url(version)))
else:
self.error(400, "Bad Data")
else:
self.error(404, "API Version %s not supported" % version)
def save(self,
force_insert=False,
force_update=False,
using=None,
update_fields=None):
self.slug = slugify(self.title)
return super(Blog, self).save(force_insert, force_update, using,
update_fields)
def save(self, *args, **kwargs):
if self.title:
self.slug = slugify(self.title)
if not self.order:
last = Conference.objects.all().aggregate(
Max('order')).get('order__max')
print(last)
if last:
self.order = last + 1
else:
self.order = 1
super().save(*args, **kwargs)
def tareas_categorias(categorias):
previous_task = None
for i in categorias:
task = DummyOperator(task_id=slugify(i['actividad'])[:20], dag=dag)
if previous_task:
previous_task.set_downstream(task)
else:
start_node.set_downstream(task)
previous_task = task
task.set_downstream(end_node)
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
image_slug = self.request.get('image', default_value=None)
default = self.request.get('default', default_value="false")
if default not in ["true", "false"]:
self.error(400, "Default must be true or false")
return
if not name or not description or not image_slug:
self.error(400, "Bad Data")
return
slug = slugify.slugify(name)
status = Status.get_by_slug(slug)
image = Image.get_by_slug(image_slug)
if status is not None:
self.error(400, "A Status with the slug %s already exists" % slug)
return
if image is None:
msg = "An Image with the slug %s doesn't exist" % image_slug
self.error(400, msg)
return
# Reset default status
if default == "true":
for stat in Status.all().filter("default", True):
stat.default = False
stat.put()
default = default == "true"
status = Status(name=name,
slug=slug,
description=description,
image=image.path,
default=default)
status.put()
invalidate_cache()
self.response.set_status(201)
self.json(status.rest(self.base_url(version)))
def post(self):
"""
name -- string: The name of this tv series
slug -- stirng: URL friendly version of the name
quality -- string: The quality of the tv series to watch for
requester -- user: The user who first asked to track the show
addDate -- datetime: When this show started being tracked
active -- boolean: Is Active?
minimumSeason -- integer: Lowest season number to care about
"""
name = self.request.get("name", default_value=None)
quality = self.request.get("quality", default_value=None)
active = self.request.get("active", default_value=True) == "true"
minimumSeasonTxt = self.request.get("minimumSeason", default_value=None)
authUsername = self.request.get("authUsername", default_value=None)
authPassword = self.request.get("authPassword", default_value=None)
if not name or not quality:
self.error(400, "Bad Data: Name: %s, quality: %s" % (name, quality))
return
name = string.replace(name, ".", " ")
slug = slugify.slugify(name)
existing_s = TrackedSeries.get_by_slug(slug)
if existing_s:
self.error(400, "A TV show with this name already exists")
return
minimumSeason = None
if minimumSeasonTxt:
minimumSeason = int(minimumSeasonTxt)
s = TrackedSeries(
name=name,
slug=slug,
quality=quality,
active=active,
requester=users.get_current_user(),
addDate=datetime.now(),
minimumSeason=minimumSeason,
)
s.put()
invalidate_cache("shows")
self.redirect("/admin/shows/" + slug)
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
image_slug = self.request.get('image', default_value=None)
default = self.request.get('default', default_value="false")
if default not in ["true", "false"]:
self.error(400, "Default must be true or false")
return
if not name or not description or not image_slug:
self.error(400, "Bad Data")
return
slug = slugify.slugify(name)
status = Status.get_by_slug(slug)
image = Image.get_by_slug(image_slug)
if status is not None:
self.error(400, "A Status with the slug %s already exists" % slug)
return
if image is None:
msg = "An Image with the slug %s doesn't exist" % image_slug
self.error(400, msg)
return
# Reset default status
if default == "true":
for stat in Status.all().filter("default", True):
stat.default = False
stat.put()
default = default == "true"
status = Status(name=name, slug=slug, description=description,
image=image.path, default=default)
status.put()
invalidate_cache()
self.response.set_status(201)
self.json(status.rest(self.base_url(version)))
def post(self):
"""
name -- string: The name of this file source
slug -- stirng: URL friendly version of the name
rssUrl -- string: The rss feed url
quality -- string: The quality of the files in this source
zipped -- boolean: Are the files from this source zip files?
authorizationRequired -- boolean: When downloading the file, is authorization required?
authUsername -- string: authorization username
authPassword -- string: authorization password
"""
name = self.request.get("name", default_value=None)
rssUrl = self.request.get("rssUrl", default_value=None)
quality = self.request.get("quality", default_value=None)
zipped = self.request.get("zipped", default_value=False) == "true"
authorizationRequired = self.request.get("authorizationRequired", default_value=False) == "true"
authUsername = self.request.get("authUsername", default_value=None)
authPassword = self.request.get("authPassword", default_value=None)
if not name or not rssUrl or not quality:
self.error(400, "Bad Data: Name: %s, rssUrl: %s, quality: %s" % (name, rssUrl, quality))
return
slug = slugify.slugify(name)
existing_s = FileSource.get_by_slug(slug)
if existing_s:
self.error(400, "A source with this name already exists")
return
s = FileSource(
name=name,
slug=slug,
rssUrl=rssUrl,
quality=quality,
zipped=zipped,
authorizationRequired=authorizationRequired,
authUsername=authUsername,
authPassword=authPassword,
)
s.put()
invalidate_cache("sources")
self.redirect("/admin/sources/" + slug)
def post(self, slug):
"""
name -- string: The name of this file source
slug -- stirng: URL friendly version of the name
rssUrl -- string: The rss feed url
quality -- string: The quality of the files in this source
zipped -- boolean: Are the files from this source zip files?
authorizationRequired -- boolean: When downloading the file, is authorization required?
authUsername -- string: authorization username
authPassword -- string: authorization password
"""
existing_s = FileSource.get_by_slug(slug)
if not existing_s:
self.error(400, "Cannot find an existing source to edit")
return
name = self.request.get('name', default_value=None)
newSlug = slugify.slugify(name)
rssUrl = self.request.get('rssUrl', default_value=None)
quality = self.request.get('quality', default_value=None)
zipped = self.request.get('zipped', default_value=False) == "true"
authorizationRequired = self.request.get('authorizationRequired', default_value=False) == "true"
authUsername = self.request.get('authUsername', default_value=None)
authPassword = self.request.get('authPassword', default_value=None)
if not name or not rssUrl or not quality:
self.error(400, "Bad Data: Name: %s, rssUrl: %s, quality: %s" % (name, rssUrl, quality))
return
existing_s.name = name
existing_s.slug = newSlug
existing_s.rssUrl = rssUrl
existing_s.quality = quality
existing_s.zipped = zipped
existing_s.authorizationRequired = authorizationRequired
existing_s.authUsername = authUsername
existing_s.authPassword = authPassword
existing_s.put()
invalidate_cache("sources")
self.redirect("/admin/sources/"+newSlug)
def post(self,slug):
"""
name -- string: The name of this tv series
slug -- stirng: URL friendly version of the name
quality -- string: The quality of the tv series to watch for
requester -- user: The user who first asked to track the show
addDate -- datetime: When this show started being tracked
active -- boolean: Is Active?
minimumSeason -- integer: Lowest season number to care about
"""
existing_s = TrackedSeries.get_by_slug(slug)
if not existing_s:
self.error(400, "Cannot find an existing TV show to edit")
return
name = self.request.get('name', default_value=None)
quality = self.request.get('quality', default_value=None)
active = self.request.get('active', default_value=True) == "true"
minimumSeasonTxt = self.request.get('minimumSeason', default_value=None)
authUsername = self.request.get('authUsername', default_value=None)
authPassword = self.request.get('authPassword', default_value=None)
if not name or not quality:
self.error(400, "Bad Data: Name: %s, quality: %s" % (name, quality))
return
minimumSeason = None
if minimumSeasonTxt:
minimumSeason = int(minimumSeasonTxt)
existing_s.name = name
existing_s.slug = slugify.slugify(name)
existing_s.quality = quality
existing_s.active = active
existing_s.minimumSeason = minimumSeason
existing_s.put()
invalidate_cache("shows")
self.redirect("/admin/shows/"+existing_s.slug)
def post(self):
"""
name -- string: The name of this tv series
slug -- stirng: URL friendly version of the name
quality -- string: The quality of the tv series to watch for
requester -- user: The user who first asked to track the show
addDate -- datetime: When this show started being tracked
active -- boolean: Is Active?
minimumSeason -- integer: Lowest season number to care about
"""
name = self.request.get('name', default_value=None)
quality = self.request.get('quality', default_value=None)
active = self.request.get('active', default_value=True) == "true"
minimumSeasonTxt = self.request.get('minimumSeason', default_value=None)
authUsername = self.request.get('authUsername', default_value=None)
authPassword = self.request.get('authPassword', default_value=None)
if not name or not quality:
self.error(400, "Bad Data: Name: %s, quality: %s" % (name, quality))
return
name = string.replace(name, ".", " ")
slug = slugify.slugify(name)
existing_s = TrackedSeries.get_by_slug(slug)
if existing_s:
self.error(400, "A TV show with this name already exists")
return
minimumSeason = None
if minimumSeasonTxt:
minimumSeason = int(minimumSeasonTxt)
s = TrackedSeries(name=name, slug=slug, quality=quality, active=active, requester=users.get_current_user(),
addDate=datetime.now(), minimumSeason=minimumSeason)
s.put()
invalidate_cache("shows")
self.redirect("/admin/shows/"+slug)
def post(self, slug):
"""
name -- string: The name of this tv series
slug -- stirng: URL friendly version of the name
quality -- string: The quality of the tv series to watch for
requester -- user: The user who first asked to track the show
addDate -- datetime: When this show started being tracked
active -- boolean: Is Active?
minimumSeason -- integer: Lowest season number to care about
"""
existing_s = TrackedSeries.get_by_slug(slug)
if not existing_s:
self.error(400, "Cannot find an existing TV show to edit")
return
name = self.request.get("name", default_value=None)
quality = self.request.get("quality", default_value=None)
active = self.request.get("active", default_value=True) == "true"
minimumSeasonTxt = self.request.get("minimumSeason", default_value=None)
authUsername = self.request.get("authUsername", default_value=None)
authPassword = self.request.get("authPassword", default_value=None)
if not name or not quality:
self.error(400, "Bad Data: Name: %s, quality: %s" % (name, quality))
return
minimumSeason = None
if minimumSeasonTxt:
minimumSeason = int(minimumSeasonTxt)
existing_s.name = name
existing_s.slug = slugify.slugify(name)
existing_s.quality = quality
existing_s.active = active
existing_s.minimumSeason = minimumSeason
existing_s.put()
invalidate_cache("shows")
self.redirect("/admin/shows/" + existing_s.slug)
def post(self, version):
if self.valid_version(version):
name = self.request.get("name", default_value=None)
description = self.request.get("description", default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if not existing_s:
s = Service(name=name, slug=slug, description=description)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(404, "A sevice with this name already exists")
else:
self.error(400, "Bad Data: Name: %s, Description: %s" % (name, description))
else:
self.error(404, "API Version %s not supported" % version)
def cargar_datos(shows):
import imdb
from series.models import Serie, Genero
from utils.slugify import slugify
api = imdb.IMDb()
for show in shows:
try:
try:
datos = api.get_movie( show["imdb"].movieID )
except:
continue
s = Serie()
s.titulo = datos.get("title")
print s.titulo
s.slug = slugify(s.titulo)
try:
s.productora = (",".join( [c.get("name") for c in datos.get("production companies")] ))[:255]
except:
pass
s.director = datos.get("director")
s.estado = show["status"]
try:
s.plot = datos.get("plot")[0]
except:
pass
s.mini_plot = datos.get("plot outline")
s.year = datos.get("year")
s.cover = datos.get("full-size cover url")
s.min_cover = datos.get("cover url")
s.rating = datos.get("rating")
if not s.rating:
s.rating = 0
s.imdb_id = show["imdb"].movieID
s.save()
for g in datos.get("genres"):
gen, created = Genero.objects.get_or_create(nombre=g)
s.genero.add( gen )
except:
pass
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
slist = self.request.get('list', default_value=None)
l = None
if slist:
l = List.all().filter("slug =", slist).get()
if not name:
self.error(400, "Bad name: %s" % name)
return
if not description:
self.error(400, "Bad description: %s" % description)
return
if slist and not l:
self.error(400, "Bad list slug: %s" % slist)
return
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
if existing_s:
self.error(404, "A sevice with this name already exists")
return
s = Service(name=name, slug=slug, description=description, list=l)
s.put()
invalidate_cache()
self.response.set_status(201)
self.json(s.rest(self.base_url(version)))
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
slist = self.request.get('list', default_value=None)
l = None
if slist:
l = List.all().filter("slug =", slist).get()
if not name:
self.error(400, "Bad name: %s" % name)
return
if not description:
self.error(400, "Bad description: %s" % description)
return
if slist and not l:
self.error(400, "Bad list slug: %s" % slist)
return
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
if existing_s:
self.error(404, "A sevice with this name already exists")
return
s = Service(name=name, slug=slug, description=description, list=l)
s.put()
invalidate_cache()
self.response.set_status(201)
self.json(s.rest(self.base_url(version)))
def post(self, version):
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
if name and description:
slug = slugify.slugify(name)
existing_s = Service.get_by_slug(slug)
# Update existing resource
if not existing_s:
s = Service(name=name, slug=slug, description=description)
s.put()
self.json(s.rest(self.base_url(version)))
else:
self.error(404, "A sevice with this name already exists")
else:
self.error(
400, "Bad Data: Name: %s, Description: %s" %
(name, description))
else:
self.error(404, "API Version %s not supported" % version)
def test_slugify_horrible_name(self):
self.assertEquals(slugify.slugify(u'reallt BAD NAME ^ç--(23àçè-'),
"reallt-bad-name-c-23ace")
def save(self, *args, **kwargs):
if self.title:
self.slug = slugify(self.title)
super(Project, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
if self.parent_category:
self.level = self.parent_category.level + 1
self.slug = slugify(self.name)
super().save(*args, **kwargs)
def save(self, *args, **kwargs):
self.slug = slugify(self.name)
super().save(*args, **kwargs)
def save(self, force_insert=False, force_update=False, using=None,
update_fields=None):
self.slug = slugify(self.title)
return super(Blog, self).save(force_insert, force_update, using, update_fields)
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.title)
super(Item, self).save(*args, **kwargs)
def slugify(name, region=''):
return slugify.slugify(region +'-' + name)
def post(self, **kwargs):
'''Insert a doc
newDocTmp: Initialize a temp (tmp) doc if no OID and no data.
cloneDocTmp: Clone to a temp doc if OID and no isTmp flag set.
upsertDocTmp: Update or Insert temp doc to base collection if OID and isTmp is set.
insertDoc: Insert a new doc if no OID and there are more attributes than _c.
'''
db = self.db
response = {}
docs = []
status = 200
usrOID = self.usr['OID']
docs_to_post = kwargs['docs']
post_errors = []
total_errors = 0
for doc in docs_to_post:
errors = {}
doc_info = {}
# required attribute
_c = doc['_c']
# shortcut
doc_keys = doc.keys()
modelClass = getattr(models, _c)
_id = doc['_id'] if '_id' in doc_keys else None
where = {'_id': ObjectId(_id)} if _id else None
attrNam = doc['attrNam'] if 'attrNam' in doc_keys else None
attr_c = doc['attr_c'] if attrNam else None
attrVal = doc['attrVal'] if attrNam else None
collNam = modelClass.meta['collection']
collTmp = db[collNam + '_tmp']
coll = db[collNam]
# if _ id is passed, it directs that a temp doc be initialized and inserted into the appropriate Tmp (temp) collection.
# if an _id IS passed, it directs that the doc passed in be validated and inserted in the base collection and the temp doc in the temp collection be deleted.
# if attrNam, posting a new value to a listtype attribute/field
if attrNam:
for elem in attrVal:
modelClass = getattr(models.embed, attr_c)
model = modelClass()
for k,v in elem.iteritems(): setattr(model, k, v)
resp = nextEId(doc, attrNam)
doc = resp['doc']
# model.eIds = doc['eIds']
model.eId = resp['eId']
if hasattr(model, 'vNam') and 'dNam' in model._fields and not model.dNam:
model.dNam = model.vNam
# generate a slug if slug is empty
if 'slug' in model._fields and 'dNam' in model._fields and not model.slug:
model.slug = slugify(model.dNam, coll)
# set dNamS if used:
# if dNamS is empty, set to value of slug
if 'dNamS' in model._fields and not model.dNamS:
if hasattr(model, 'vNamS'):
model.dNamS = model.vNamS
else:
model.dNamS = model.slug
embedDoc = doc_remove_empty_keys(to_python(model, allow_none=True))
doc_errors = validate(modelClass, embedDoc)
if doc_errors:
total_errors += doc_errors['count']
post_errors.append(doc_errors)
continue
embedDoc['_c'] = attr_c
# logit update
embedDoc = logit(self.usr, embedDoc, method='post')
collTmp.update(where,
{"$push": { attrNam: embedDoc}, "$set": {'eIds': doc['eIds']}}
)
doc_info['doc'] = embedDoc
docs.append(doc_info)
# http://docs.mongodb.org/manual/applications/update/
# { $set: { 'emails.$.eId': 2 }
response['total_inserted'] = len(docs)
if post_errors:
response['total_invalid'] = len(post_errors)
response['errors'] = post_errors
response['total_errors'] = total_errors
status = 400
else:
response['total_invalid'] = 0
response['docs'] = docs
return {'response': response, 'status': status}
# Initialize a temp (tmp) doc if no OID and no data.
elif not '_id' in doc_keys and len(doc_keys) == 1:
newDocTmp = True
useTmpDoc = True
# Clone to a temp doc if OID and no isTmp flag set.
elif '_id' in doc_keys and not 'isTmp' in doc_keys and len(doc_keys) > 2:
cloneDocTmp = True
useTmpDoc = True
# find source doc
# set locked = True
doc_cloned = coll.find_and_modify(
query = {'_id':_id},
update = {"$set": {'locked': True}},
new = True
)
# set cloned doc in tmp collection isTmp = True
doc_cloned['isTmp'] = True
# don't need locked set in tmp doc
del doc_cloned['locked']
# clone/save doc to tmp collection
# TODO properly handle exception
try:
collTmp.insert(doc_cloned)
except:
pass
doc_info['doc'] = doc_cloned
# TODO
# should return a link to object according to good practice
#doc_info['link'] = get_document_link(class_name, id)
docs.append(doc_info)
continue
# Update temp doc to base collection if OID and isTmp is set.
elif '_id' in doc_keys and 'isTmp' in doc_keys and doc['isTmp']:
upsertDocTmp = True
useTmpDoc = False
tmp_doc = collTmp.find_one({'_id': _id})
# unset isTmp
_id = tmp_doc['_id']
tmp_doc['locked'] = False
del tmp_doc['_id']
del tmp_doc['isTmp']
# logit update
tmp_doc = logit(self.usr, tmp_doc)
# update original/source doc
doc = coll.update({'_id': _id}, {"$set": tmp_doc}, upsert=True, safe=True)
# remove tmp doc
collTmp.remove({'_id': _id})
# though not necessary, to be consistant, return full doc
doc = coll.find_one({'_id': _id})
doc_info['doc'] = doc
docs.append(doc_info)
continue
# Insert a new doc if no OID and there are more attributes than _c.
elif not '_id' in doc_keys and len(doc_keys) > 2:
insertDoc = True
useTmpDoc = False
# need to cruz through all doc keys to handle arrays/listtype fields.
# they need to be initialized according to the appropriate model and validated, etc.
doc = initDocListTypes(doc, self.usr)
# init model instance
model = modelClass(**doc)
# set isTemp
model.isTmp = useTmpDoc and 'isTmp' in model._fields
# try to generate dNam
# if there is a vNam class property
# if already has a value, use it
if hasattr(model, 'vNam') and not useTmpDoc and 'dNam' in model._fields and not model.dNam:
model.dNam = model.vNam
# assign dId
if 'dId' in model._fields and not model.dId:
response = nextId(coll)
if response['status'] == 200:
model.dId = response['nextId']
else:
# handle error condition
pass
# generate a slug if:
# not a temp doc and slug is empty
if 'slug' in model._fields and not useTmpDoc and not model.slug:
model.slug = slugify(model.dNam, coll)
# set dNamS if used:
# not a temp doc and dNamS is empty, set to value of slug
if 'dNamS' in model._fields and not useTmpDoc and not model.dNamS:
model.dNamS = model.slug
# do not validate if using temp doc
if not useTmpDoc:
doc_errors = validate(modelClass, doc)
if doc_errors:
total_errors += doc_errors['count']
post_errors.append(doc_errors)
continue
# modelClass stuffed in all available fields
# let's remove all empty fields to keep mongo clean.
doc = to_python(model, allow_none=True)
# do not log if using temp doc
#log date time user involved with this event
if not useTmpDoc:
doc = logit(self.usr, doc, 'post')
doc['_c'] = _c
doc_clean = doc_remove_empty_keys(doc)
# posting an existing temp doc to base collection
if _id:
doc_clean['_id'] = str(_id)
id = str(coll.insert(doc_clean))
# TODO properly handle exception
try:
collTmp.remove({'_id': _id})
except:
pass
# posting initialized temp doc
else:
# TODO properly handle exception
try:
coll.insert(doc_clean)
except:
pass
doc_info['doc'] = doc_clean
# TODO
# should return a link to object according to good practice
#doc_info['link'] = get_document_link(class_name, id)
docs.append(doc_info)
response['total_inserted'] = len(docs)
if post_errors:
response['total_invalid'] = len(post_errors)
response['errors'] = post_errors
response['total_errors'] = total_errors
status = 400
else:
response['total_invalid'] = 0
response['docs'] = docs
return {'response': response, 'status': status}
def test_slugify_name_with_int(self):
self.assertEquals(slugify.slugify(u'Xbox Gamepad (userspace driver) #2'), "xbox-gamepad-userspace-driver-2")
def test_slugify_horrible_name(self):
self.assertEquals(slugify.slugify(u'reallt BAD NAME ^ç--(23àçè-'), "reallt-bad-name-c-23ace")
def final_step():
search = request.form.get('search')
fiasId = request.form.get('houses')
if not (fiasId or session['result']):
abort(400)
_resu = result_search(fiasId, session['result'])[0]
site_params = {
"name": '',
"slug": '',
"region": '',
"description": '',
}
if _resu['contentType'] == 'building':
print(_resu['fullName'])
_street = result_search(_resu['parentGuid'], _resu["parents"])[0]
site_name1 = ' '.join([replace_answer_fias(_street['typeShort']), _street['name'], _resu['name']])
site_name2 = transliterate(site_name1)
site_name3 = site_name2.replace('/', '-')
site_name4 = slugify(site_name3)
site_desc1 = '. '.join([_street['typeShort'], _street['name']])
site_desc2 = ' '.join([site_desc1, _resu['name']])
region = nb.dcim.regions.filter(slug=session['region_slug'])[0]
site_params = {
"name": site_name2,
"slug": site_name4,
"region": region.id,
"description": site_desc2,
}
try:
nb.dcim.sites.create(**site_params)
flash('Сайт создан успешно', category='success')
except pynetbox.core.query.RequestError as ex:
flash('Такой сайт уже существует', category='warning')
else:
flash('Такого дома в КЛАДРе нет.', category='warning')
flash('Используем номер дома введенного вручную', category='warning')
number_of_house = search.split(' ')[-1]
_number_of_house = re.match('^\d+', number_of_house)
if _number_of_house:
_site_name_rus = ' '.join ([ _resu['typeShort'], _resu['name'], number_of_house ])
_site_name_trans = transliterate(_site_name_rus)
_slug_eng = _site_name_trans.replace('/', '-')
_slug_slugifyed = slugify(_slug_eng)
_site_desc = '. '.join([ _resu['typeShort'], _resu['name'] ])
_site_desc2 = ' '.join([_site_desc, number_of_house])
region = nb.dcim.regions.filter(slug=session['region_slug'])[0]
site_params = {
"slug": _slug_slugifyed,
"name": _site_name_trans,
"region": region.id,
"description": _site_desc2,
}
try:
nb.dcim.sites.create(**site_params)
flash('Сайт создан успешно', category='success')
except:
flash('Такой сайт уже существует', category='warning')
else:
flash('Вы неправильно ввели в поиске номер дома', category='danger')
return render_template('sites/step4.html', nb_url=nb_url, data={'site_params': site_params} )
def test_slugify_name_with_int(self):
self.assertEquals(
slugify.slugify(u'Xbox Gamepad (userspace driver) #2'),
"xbox-gamepad-userspace-driver-2")
