class ProjectPart(models.Model):
project = models.ForeignKey(Project)
project_part = models.ForeignKey('self', null=True, blank=True)
title = models.CharField(max_length=255)
order = models.IntegerField(null=True)
created_user = models.ForeignKey(User,
related_name='projectpart_created_user')
created = models.DateTimeField(null=True, blank=True, default=now())
modified_user = models.ForeignKey(User,
null=True,
blank=True,
related_name='projectpart_modified_user')
modified = models.DateTimeField(null=True, blank=True, default=now())
drive_id = models.CharField(max_length=100, blank=True, null=True)
class Meta:
db_table = u'project_part'
def __unicode__(self):
return u'%d - %s' % (self.id, self.title)
def progress(self):
return self.post_set.all().count() + self.task_count()
def task_count(self):
return self.task_set.all().count()
def progress_done(self):
return self.task_set.filter(flag_finished=1).count()
def has_drive(self):
return bool(self.drive_id)
def obj_create(self, bundle, **kwargs):
created = now()
return super(DocumentResource,
self).obj_create(bundle,
created=created,
status=0,
created_user=bundle.request.user)
class UserProject(models.Model):
CHOICES = ((1, 'ADMIN'), (0, 'USER'))
user = models.ForeignKey(User)
project = models.ForeignKey(Project, db_column='project_id')
permission = models.IntegerField(max_length=2, default=0, choices=CHOICES)
created_user = models.ForeignKey(User,
related_name='userproject_created_user')
created = models.DateTimeField(default=now(), null=True, blank=True)
modified_user = models.ForeignKey(User,
null=True,
blank=True,
related_name='userproject_modified_user')
modified = models.DateTimeField(null=True, blank=True)
drive_auth = models.BooleanField(default=False)
objects = UserProjectManager()
class Meta:
db_table = u'user_project'
def __unicode__(self):
return u'%s' % self.id
def is_admin(self):
return self.permission == 1
class Task(models.Model):
project_part = models.ForeignKey(ProjectPart)
description = models.TextField()
skill = models.IntegerField(null=True, db_column='skill_id')
user = models.ForeignKey(User, null=True, db_column='user_id')
deadline = models.DateTimeField(null=True, blank=True)
flag_finished = models.IntegerField(max_length=1, default=0)
created_user = models.ForeignKey(User, related_name='task_created_user')
created = models.DateTimeField(null=True, blank=True, default=now())
modified_user = models.ForeignKey(User,
null=True,
blank=True,
related_name='task_modified_user')
modified = models.DateTimeField(null=True, blank=True)
weight = models.IntegerField(max_length=255, default=0)
class Meta:
db_table = u'task'
def __unicode__(self):
return u'%s' % self.description
def get_absolute_url(self):
return '/'.join([
'/#/project',
str(self.project_part.project.id), 'parts',
str(self.project_part.id), 'task',
str(self.id)
])
def obj_create(self, bundle, **kwargs):
created = now()
result = super(PostResource, self).obj_create(bundle,
created=created,
created_user=bundle.request.user)
bundle.obj.set_post_data()
return result
def obj_create(self, bundle, **kwargs):
created = now()
result = super(PostResource,
self).obj_create(bundle,
created=created,
created_user=bundle.request.user)
bundle.obj.set_post_data()
return result
def format_datetime(self, dt):
date = super(MomentSerializer, self).format_datetime(dt)
today = now()
if today.day == date.day:
return ' - '.join(['today', dateformat.format(date, 'H:i')])
elif today - timedelta(days=1) == date:
return ' - '.join(['yesterday', dateformat.format(date, 'H:i')])
else:
return dateformat.format(date, 'jS F Y - H:i')
def format_datetime(self, dt):
date = super(MomentSerializer, self).format_datetime(dt)
today = now()
if today.day == date.day:
return ' - '.join(['today', dateformat.format(date, 'H:i')])
elif today - timedelta(days=1) == date:
return ' - '.join(['yesterday', dateformat.format(date, 'H:i')])
else:
return dateformat.format(date, 'jS F Y - H:i')
def is_valid(self):
" Check if token is still valid."
# Get valid period.
valid_time = getattr(settings, 'TOKEN_VALID_TIME', 3600)
_now = now()
if (_now - self.last) < datetime.timedelta(seconds=valid_time):
self.last = _now
self.save()
return True
return False
def get_created_date(self):
today = now()
if today.day == self.created.day:
return ' - '.join(['today',
dateformat.format(timezone.localtime(self.created), 'H:i')])
elif (today - timedelta(days=1)).date() == self.created.date():
return ' - '.join(['yesterday',
dateformat.format(timezone.localtime(self.created), 'H:i')])
else:
return dateformat.format(timezone.localtime(self.created), 'jS F Y - H:i')
class Skill(models.Model):
name = models.CharField(max_length=150, unique=True)
created_user = models.ForeignKey(User, related_name='skill_created_user')
created = models.DateTimeField(null=True, blank=True, default=now())
modified_user = models.ForeignKey(User,
null=True,
blank=True,
related_name='skill_modified_user')
modified = models.DateTimeField(null=True, blank=True)
class Meta:
db_table = u'skill'
def obj_create(self, bundle, request=None, **kwargs):
try:
userProfile = User.objects.get(
pk=bundle.request.user.id).get_profile()
except:
raise ImmediateHttpResponse(response=http.HttpNotFound())
try:
obj = self.fields['parent'].build_related_resource(
bundle.data['parent']).obj
except:
raise ImmediateHttpResponse(response=http.HttpNotFound())
if obj.vote_set.filter(owner_id=userProfile.pk).exists():
bundle.obj = obj.vote_set.get(owner_id=userProfile.pk)
if bundle.obj.is_active is not True:
bundle.obj.IPaddress = bundle.request.META['REMOTE_ADDR']
bundle.obj.is_active = True
bundle.obj.created_time = now()
else:
bundle.obj.parent = obj
bundle.obj.IPaddress = bundle.request.META['REMOTE_ADDR']
bundle.obj.owner = userProfile
if hasattr(bundle.obj, 'total_votes'):
bundle.obj.total_votes = bundle.obj.total_votes()
bundle.obj.save()
# email owner of the image that this vote modifies
if bundle.obj.parent.obj_type() == 'image':
parent_owner = bundle.obj.parent.owner
vote_owner = bundle.obj.owner
if parent_owner != vote_owner:
media_url = u'{page_base_url}image/{uuid}'.format(
page_base_url=PAGE_BASE_URL,
uuid=bundle.obj.parent.uuid)
vote_owner_url = u'{base_url}{vote_owner}'.format(
base_url=BASE_URL,
vote_owner=vote_owner.username)
# send email to the owner of the image
send_mail(u'Dujour: New vote on your photo!',
u'Hi {parent_owner}!\n\n'.format(
parent_owner=parent_owner.first_name) +
u'{vote_owner} voted on your photo at'
u'{media_url}.\n\n'.format(
vote_owner=vote_owner.first_name,
media_url=media_url) +
u'Take a look at {vote_owner}\'s profile here:'
u'{vote_owner_url}\n\n'.format(
vote_owner=vote_owner.first_name,
vote_owner_url=vote_owner_url) +
u'- Dujour Team',
u'*****@*****.**',
[str(parent_owner.email)],
fail_silently=False)
return bundle
def audit(self, request, **kwargs):
self.method_check(request, allowed=["post", "delete", 'put'])
self.is_authenticated(request)
ug = UserGroup.objects.get(id=kwargs['id'])
if request.method.lower() == "delete":
ug_user = ug.user
if perms.may_del_user_group(request.user, ug):
ug.group.user_set.remove(ug_user)
ug.delete()
LogEntry.objects.log_action(
user_id=request.user.pk,
content_type_id=ContentType.objects.get_for_model(ug.group).pk,
object_id=ug.group.pk,
object_repr=force_unicode(ug.group),
action_flag=2,
change_message="{user}从{group}组移除了{user1}".format(user=force_unicode(request.user),
user1=force_unicode(ug_user),
group=force_unicode(ug.group))
)
return self.create_response(request, {"status": True})
if request.method.lower() == "put":
if perms.may_admin_user_group(request.user, ug):
ug.user_type = 'administrator'
ug.save()
LogEntry.objects.log_action(
user_id=request.user.pk,
content_type_id=ContentType.objects.get_for_model(ug.group).pk,
object_id=ug.group.pk,
object_repr=force_unicode(ug.group),
action_flag=2,
change_message="{user}设置{user1}为{group}组管理员".format(user=force_unicode(request.user),
user1=force_unicode(ug.user),
group=force_unicode(ug.group))
)
return self.create_response(request, {"status": True})
else:
if not ug.is_active and perms.may_audit_user_group(request.user, ug):
ug.is_active = now()
ug.save()
LogEntry.objects.log_action(
user_id=request.user.pk,
content_type_id=ContentType.objects.get_for_model(ug.group).pk,
object_id=ug.group.pk,
object_repr=force_unicode(ug.group),
action_flag=2,
change_message="{user}审批通过{user1}加入{group}组".format(user=force_unicode(request.user),
user1=force_unicode(ug.user),
group=force_unicode(ug.group))
)
return self.create_response(request, {"status": True})
class TaskUser(models.Model):
task = models.ForeignKey(Task)
user = models.ForeignKey(User)
created_user = models.ForeignKey(User,
related_name='taskuser_created_user')
created = models.DateTimeField(null=True, blank=True, default=now())
modified_user = models.ForeignKey(User,
null=True,
blank=True,
related_name='taskuser_modified_user')
modified = models.DateTimeField(null=True, blank=True)
class Meta:
db_table = u'task_user'
class Document(models.Model):
project_part = models.ForeignKey(ProjectPart)
text = models.TextField(blank=True)
status = models.IntegerField()
created_user = models.ForeignKey(User,
related_name='document_created_user')
created = models.DateTimeField(default=now(),
null=True, blank=True)
modified_user = models.ForeignKey(User, null=True,
blank=True,
related_name='document_modified_user')
modified = models.DateTimeField(null=True, blank=True)
class Meta:
db_table = u'document'
def obj_create(self, bundle, request=None, **kwargs):
try:
userProfile = User.objects.get(
pk=bundle.request.user.id).get_profile()
except:
raise ImmediateHttpResponse(response=http.HttpNotFound())
try:
obj = self.fields['parent'].build_related_resource(
bundle.data['parent']).obj
except:
raise ImmediateHttpResponse(response=http.HttpNotFound())
if obj.vote_set.filter(owner_id=userProfile.pk).exists():
bundle.obj = obj.vote_set.get(owner_id=userProfile.pk)
if bundle.obj.is_active is not True:
bundle.obj.IPaddress = bundle.request.META['REMOTE_ADDR']
bundle.obj.is_active = True
bundle.obj.created_time = now()
else:
bundle.obj.parent = obj
bundle.obj.IPaddress = bundle.request.META['REMOTE_ADDR']
bundle.obj.owner = userProfile
if hasattr(bundle.obj, 'total_votes'):
bundle.obj.total_votes = bundle.obj.total_votes()
bundle.obj.save()
# email owner of the image that this vote modifies
if bundle.obj.parent.obj_type() == 'image':
parent_owner = bundle.obj.parent.owner
vote_owner = bundle.obj.owner
if parent_owner != vote_owner:
media_url = u'{page_base_url}image/{uuid}'.format(
page_base_url=PAGE_BASE_URL, uuid=bundle.obj.parent.uuid)
vote_owner_url = u'{base_url}{vote_owner}'.format(
base_url=BASE_URL, vote_owner=vote_owner.username)
# send email to the owner of the image
send_mail(
u'Dujour: New vote on your photo!',
u'Hi {parent_owner}!\n\n'.format(
parent_owner=parent_owner.first_name) +
u'{vote_owner} voted on your photo at'
u'{media_url}.\n\n'.format(
vote_owner=vote_owner.first_name, media_url=media_url)
+ u'Take a look at {vote_owner}\'s profile here:'
u'{vote_owner_url}\n\n'.format(
vote_owner=vote_owner.first_name,
vote_owner_url=vote_owner_url) + u'- Dujour Team',
u'*****@*****.**', [str(parent_owner.email)],
fail_silently=False)
return bundle
class Comment(models.Model):
post = models.ForeignKey(Post, null=True, blank=True)
task = models.ForeignKey(Task, null=True, blank=True)
comment = models.ForeignKey('self', null=True, blank=True,
related_name='own_comments')
text = models.TextField(db_column='comment')
created_user = models.ForeignKey(User)
created = models.DateTimeField(default=now(),
null=True,
blank=True)
class Meta:
db_table = u'comment'
def __unicode__(self):
return u'%s' % self.comment
class UserSkill(models.Model):
user = models.ForeignKey(User)
skill = models.ForeignKey(Skill)
created_user = models.ForeignKey(User,
related_name='userskill_created_user')
created = models.DateTimeField(null=True, blank=True, default=now())
modified_user_id1 = models.ForeignKey(
User,
null=True,
db_column='modified_user_id1',
blank=True,
related_name='userskill_modified_user')
modified = models.DateTimeField(null=True, blank=True)
class Meta:
db_table = u'user_skill'
def obj_create(self, bundle, **kwargs):
datastore_index = json.loads(bundle.request.body)['data']['index']
datastore_id = json.loads(bundle.request.body)['data']['id']
sketch_id = json.loads(bundle.request.body)['data']['sketch']
sketch = Sketch.objects.get(pk=sketch_id)
body = json.loads(bundle.request.body)['data']['body']
result = EventComment.objects.create(user=bundle.request.user,
datastore_index=datastore_index, datastore_id=datastore_id,
body=body, sketch=sketch, created=utils.now())
bundle.obj = result
bundle.data['data']['created'] = result.created
bundle.data['data']['user'] = {}
bundle.data['data']['user']['first_name'] = result.user.first_name
bundle.data['data']['user']['last_name'] = result.user.last_name
datastore = DATASTORE(datastore_index)
datastore.add_label_to_event(datastore_id, sketch_id,
bundle.request.user.id, "__ts_comment")
return bundle
class Post(models.Model):
project_part = models.ForeignKey(ProjectPart)
content = models.TextField()
image_name = models.CharField(max_length=255, null=True)
image_original_name = models.CharField(max_length=255, null=True)
created_user = models.ForeignKey(User, related_name='post_created_user')
created = models.DateTimeField(default=now(),
null=True, blank=True)
class Meta:
db_table = u'post'
ordering = ['-created']
def __unicode__(self):
return u'%s' % self.content
def get_content_url(self, url):
try:
response = requests.get(url, timeout=3)
except ConnectionError:
raise Http404
if response.status_code == 200:
html_content = parse_html(url, response.content)
image_res_url = ''
# FIXME we could leave this out
if html_content['image']:
if not re.search('(https?:\/\/[\w+\.]*)',
html_content['image']):
url_parsed = urlparse(url)
image_url = '/'.join(['://'.join([url_parsed.scheme,
url_parsed.netloc]), html_content['image']])
else:
image_url = html_content['image']
image_ext = html_content['image'].split('.')[-1].lower()
if len(image_ext) > 3 and image_ext != 'jpeg':
image_ext = image_ext[:3]
if image_ext in ('jpg', 'png', 'gif', 'jpeg'):
image_name = html_content['image'].split('/')[-1]
image_hash = generate_hash()
image_hash_filename = '.'.join([image_hash, image_ext])
image_res_url = os.path.join(settings.MEDIA_URL, 'posts', image_hash_filename)
try:
req_image = requests.get(image_url, timeout=3)
im = Image.open(StringIO(req_image.content))
im.save(os.path.join(settings.MEDIA_ROOT, 'posts', image_hash_filename))
self.image_name = image_name
self.image_original_name = image_hash
except IOError:
logging.error('There was an error trying to retrieve the Image from the website %s' % url)
image_res_url = ''
except ConnectionError:
logging.error('There was an error in the connection')
image_res_url = ''
text = self.content.replace(url, '')
self.content = '''<img src="%s" class="img-polaroid post-image" />
<div><a href="%s" target="_blank">%s</a>
<p>%s</p></div><br /><span>%s</span>''' % (image_res_url, url,
html_content['title'],
html_content['description'],
text)
self.save()
def check_url(self):
r = re.search('((https?:\/\/|www\.)[\w+\.]*\/?)', self.content)
if r:
url = r.group(0)
if not url.startswith('http'):
url = 'http://' + url
try:
validate = URLValidator(verify_exists=False)
validate(url)
except ValidationError:
return None
else:
url = None
return url
def set_post_data(self):
url = self.check_url()
if url:
self.get_content_url(url)
def obj_create(self, bundle, **kwargs):
created = now()
return super(TaskResource, self).obj_create(bundle,
created=created,
created_user=bundle.request.user)
def get_object_list(self, request=None, **kwargs):
date = now() - timedelta(days=settings.NOTIFICATION_WINDOW_HOURS)
return super(FriendActionResource,
self).get_object_list(request).filter(created__gte=date)
class Activity(models.Model):
ACTIONS = (('add', 'Add'), ('edit', 'Edit'),
('delete', 'Delete'))
ENTITIES = (('task', 'Task'), ('post', 'Post'), ('document', 'Document'),
('part', 'Part'), ('comment', 'Comment'), ('file', 'File'))
action = models.CharField(max_length=60, choices=ACTIONS)
entity = models.CharField(max_length=60, choices=ENTITIES)
user = models.ForeignKey(User)
created = models.DateTimeField(default=now(), null=True,
blank=True)
project_part = models.ForeignKey(ProjectPart)
related_id = models.IntegerField(max_length=30, null=True, blank=0,
default=0)
objects = ActivityManager()
def __unicode__(self):
return u'%s %s by %s' % (self.action, self.entity, self.user)
def get_url(self):
base_url = '/#/project/%d/parts/%d' % (self.project_part.project.id,
self.project_part.id)
if self.action == 'delete':
return ''
if self.entity == 'part':
return base_url
elif self.entity == 'comment':
try:
comment_data = Comment.objects.get(pk=self.related_id)
except ObjectDoesNotExist:
return ''
related_entity = ''
related_entity_id = 0
if comment_data:
if comment_data.task is not None:
related_entity = 'task'
related_entity_id = comment_data.task.id
elif comment_data.post is not None:
related_entity = 'post'
related_entity_id = comment_data.post.id
return '/'.join([base_url,
related_entity,
str(related_entity_id),
self.entity,
str(self.related_id),
])
else:
return '/'.join([base_url, self.entity,
str(self.related_id)])
def get_comment_data(self):
if self.entity == 'comment':
try:
comment_obj = Comment.objects.get(pk=self.related_id)
return model_to_dict(comment_obj)
except ObjectDoesNotExist:
return {}
else:
return {}
def get_action_name(self):
action_res = self.action
if self.action.endswith('e'):
action_res = ''.join([self.action, 'd'])
else:
action_res = ''.join([self.action, 'ed'])
return action_res
def get_created_date(self):
today = now()
if today.day == self.created.day:
return ' - '.join(['today',
dateformat.format(timezone.localtime(self.created), 'H:i')])
elif (today - timedelta(days=1)).date() == self.created.date():
return ' - '.join(['yesterday',
dateformat.format(timezone.localtime(self.created), 'H:i')])
else:
return dateformat.format(timezone.localtime(self.created), 'jS F Y - H:i')
def generate_activity(self):
user = model_to_dict(self.user)
user['username'] = '******'.join([user['first_name'], user['last_name']])
return {'action': self.get_action_name(),
'entity': self.entity,
'id': self.id,
'project_part': model_to_dict(self.project_part),
'related_id': self.related_id,
'username': user['username'],
'comment_data': self.get_comment_data(),
'url': self.get_url(),
'created': self.get_created_date(),
'project_title': self.project_part.project.title
}
class Project(models.Model):
TYPE = ((2, 'CLOSED'), (1, 'PRIVATE'), (0, 'PUBLIC'))
title = models.CharField(max_length=255, unique=True)
description = models.TextField()
type_field = models.IntegerField(db_column='type',
null=True,
blank=True,
default=1,
choices=TYPE)
image_name = models.CharField(max_length=255,
null=True,
blank=True,
default='')
image_original_name = models.CharField(max_length=255, blank=True)
licence = models.IntegerField(null=True, blank=True)
tags = models.CharField(max_length=255, blank=True)
categories = models.ManyToManyField(Category, null=True, blank=True)
created = models.DateTimeField(default=now(), null=True, blank=True)
created_user = models.ForeignKey(User)
modified = models.DateTimeField(null=True, blank=True, default=now())
drive_id = models.CharField(max_length=100, blank=True, null=True)
class Meta:
db_table = u'project'
def __unicode__(self):
return u'%d - %s' % (self.id, self.title)
def build_tree(self, tree_object):
parts = tree_object['object'].projectpart_set.all()
if parts:
tree_object['parts'] = [{
'object': part,
'parts': []
} for part in parts]
else:
return False
for part in tree_object['parts']:
self.build_tree(part)
def get_tree_struct(self):
root = self.projectpart_set.filter(project=self, project_part=None)
root = root[0] or []
tree_struct = [{'object': root, 'parts': []}]
self.build_tree(tree_struct[0])
return tree_struct
def get_maxmin_activity(self):
parts = self.projectpart_set.all()
maximum = 0
minimum = 100000000
for part in parts:
if part.progress() > maximum:
maximum = part.progress()
if part.progress() < minimum:
minimum = part.progress()
return (maximum, minimum)
def get_image_name(self):
if not self.image_name:
return '/static/images/profile-img.gif'
else:
return os.path.join('/media/project', self.image_name)
def get_user_permission(self, user):
if not user.is_authenticated():
return False
user_projects = User.objects.get(pk=user.id).userproject_set.filter(
project=self.id)
if user_projects:
# user_project = user_projects[0]
# return user_project.permission
return True
return False
def members(self, user=None):
members = [
userproject.user for userproject in self.userproject_set.all()
]
members_out = []
for member in members:
if user.id != member.id:
members_out.append({
'id':
member.id,
'username':
'******'.join([member.first_name, member.last_name]),
'image_name':
member.profile.get_image_profile(),
'city':
member.profile.city,
'country':
member.profile.country,
'state':
member.profile.state,
'number_projects':
member.userproject_set.count()
})
return members_out
def is_open(self):
return self.type_field == 0
def get_object_list(self, request=None, **kwargs):
date = now() - timedelta(days=settings.NOTIFICATION_WINDOW_HOURS)
return super(FriendActionResource, self).get_object_list(request).filter(created__gte=date)
def obj_create(self, bundle, **kwargs):
created = now()
return super(TaskResource, self).obj_create(bundle, created=created, created_user=bundle.request.user)
class File(models.Model):
project_part = models.ForeignKey(ProjectPart)
original_name = models.CharField(max_length=765, null=True)
system_name = models.CharField(max_length=765, null=True)
properties = models.CharField(max_length=765, null=True)
thumbnail = models.CharField(max_length=765, null=True)
created_user = models.ForeignKey(User)
created = models.DateTimeField(default=now(), null=True,
blank=True)
class Meta:
db_table = u'file'
def is_image(self):
mimetype = mimetypes.guess_type(self.get_file_path(True))
if mimetype[0] in settings.SUPPORTED_IMAGES:
return True
return False
def get_file_path(self, with_file=False):
file_path = os.path.join(settings.MEDIA_ROOT, 'files',
'%d' % self.project_part.id)
if not os.path.exists(file_path):
os.makedirs(file_path)
if with_file:
file_path = os.path.join(file_path, self.original_name)
return file_path
def get_thumbnail_path(self, with_file=False):
thumbnail_path = os.path.join(self.get_file_path(),
'thumbnails')
if not os.path.exists(thumbnail_path):
os.makedirs(thumbnail_path)
if with_file:
thumbnail_path = os.path.join(thumbnail_path,
self.thumbnail)
return thumbnail_path
def generate_thumbnail(self):
thumbnail_path = self.get_thumbnail_path()
thumbnail_name = generate_filename(self.original_name)
thumbnail_path = os.path.join(thumbnail_path,
thumbnail_name)
image_file = Image.open(self.get_file_path(True))
image_file.thumbnail(settings.THUMBS_SIZE, Image.ANTIALIAS)
image_file.save(thumbnail_path, image_file.format)
self.thumbnail = thumbnail_name
def set_original_name(self):
name_index = 1
namefile = self.original_name
# FIXME
self.original_name = ''.join([namefile.split('.')[0],
'(%d).' % name_index,
get_extension(self.original_name)])
while os.path.exists(self.get_file_path(True)):
name_index += 1
self.original_name = ''.join([namefile.split('.')[0],
'(%d).' % name_index,
get_extension(self.original_name)])
self.system_name = self.original_name
def delete_file(self):
try:
if self.is_image():
os.remove(self.get_thumbnail_path(True))
os.remove(self.get_file_path(True))
except OSError:
# No files
pass
def save(self, *args, **kwargs):
self.updated = now()
return super(Note, self).save(*args, **kwargs)
def obj_create(self, bundle, **kwargs):
created = now()
return super(DocumentResource, self).obj_create(bundle,
created=created,
status=0,
created_user=bundle.request.user)