class Conector(Document):
_db = get_db("couchflow")
workflow_id = schema.StringProperty()
conector_type = schema.BooleanProperty(default=True)
name = schema.StringProperty(default="Conector")
status = schema.StringProperty()
step = schema.IntegerProperty(default=0)
is_clone = schema.BooleanProperty(default=False)
start = schema.BooleanProperty(default=True)
end = schema.BooleanProperty(default=False)
active = schema.BooleanProperty()
previous_tasks = schema.ListProperty()
next_tasks = schema.ListProperty()
get_id = property(lambda self: self['_id'])
wfitems_ids = schema.ListProperty()
def put_step(self):
if not self.previous_tasks:
self.step = 1
self.save()
workflow = WorkFlow.get(self.workflow_id)
workflow.steps = self.step
return True
prev_task = get_task(self.previous_tasks[0])
self.step = prev_task.step + 1
workflow = WorkFlow.get(self.workflow_id)
workflow.steps = self.step
workflow.save()
self.save()
return True
def back_to_top(self):
previous_tasks = []
if self.previous_tasks:
for prev_task_id in self.previous_tasks:
prev_task = Task.get(prev_task_id)
previous_tasks.append(prev_task)
return previous_tasks
return None
def go_deep(self):
next_tasks = []
if self.next_tasks:
for next_task_id in self.next_tasks:
next_task = get_task(next_task_id)
next_tasks.append(next_task)
return next_tasks
return None
class Group(Document):
_db = get_db("couchauth")
name = schema.StringProperty()
users = schema.ListProperty()
max_loan_days = schema.IntegerProperty()
get_id = property(lambda self: self['_id'])
def add_user(self, user_id):
if user_id not in self.users:
self.users.append(user_id)
self.save()
return True
def del_user(self, user_id):
if user_id in self.users:
del (self.users[self.users.index(user_id)])
self.save()
return True
def update_users(self, users):
for user_id in self.users:
if user_id not in users:
user = User.get(user_id)
user.del_group(self._id)
for user_id in users:
user = User.get(user_id)
user.add_group(self._id)
def id(self):
return self._id
class BaseField(DocumentSchema):
"""
A document schema representing a WFItem base field
used by field and subfield
"""
id = schema.StringProperty()
field_name = schema.StringProperty()
repeat = schema.BooleanProperty()
type = schema.StringProperty()
default_value = schema.StringProperty()
exec_value = schema.ListProperty()
class WFItemsLoader(DynamicDataTask):
wfitems = schema.ListProperty()
multiple = schema.BooleanProperty(default=False)
order_nbr = schema.IntegerProperty()
def active_conector(self):
self.finish_task("finished")
self.save()
if self.conector_id:
conector = get_conector(self.conector_id)
if conector.doc_type != "MultipleInstances":
tasks = Task.view("couchflow/flowtask", include_docs=True)
tasks = tasks[self.workflow_id]
for task in tasks:
if task._id != self._id:
task.wfitems_ids = self.wfitems_ids
task.save()
if conector.to_next_tasks():
return True
return False
class WorkFlow(Document):
_db = get_db("couchflow")
name = schema.StringProperty()
workflow_type = schema.StringProperty()
item_type = schema.StringProperty()
user_id = schema.StringProperty()
conectors = schema.DictProperty()
nro_pedido = schema.IntegerProperty(default=0)
tasks = schema.DictProperty()
merge_conectors = schema.DictProperty()
original_task_ids = schema.DictProperty()
enabled = schema.BooleanProperty(default=False)
steps = schema.IntegerProperty(default=0)
is_clone = schema.BooleanProperty(default=False)
get_id = property(lambda self: self['_id'])
# text shown in the task
description = schema.StringProperty()
path = schema.ListProperty(schema.StringProperty())
# keep track of starting point of workflow
# usefull to get all workflows that starts
# with X task type, for example FilterItems
first_task_type = schema.StringProperty()
first_task_id = schema.StringProperty()
visible = schema.BooleanProperty(default=True)
def get_item(self):
if not self.item_type:
return False
items = WFItem.view("couchflow/item_names", limit=1, include_docs=True)
item = items[self.item_type]
item = item.one()
return item
def get_items(self):
item_query = WFItem.view("couchflow/items", include_docs=True)
items = {}
for item in item_query.all():
items[item.item_type] = (item.name, False)
if self.item_type in items:
items[self.item_type] = (items[self.item_type][0], True)
items = [(key, items[key][0], items[key][1]) for key in items]
return items
def remove_relations(self):
conectors = WorkFlow.view("couchflow/flowconector", include_docs=True)
conectors = conectors[self._id]
# TODO: bulk delete
for conector in conectors:
conector.delete()
tasks = Task.view("couchflow/flowtask", include_docs=True)
tasks = tasks[self._id]
for task in tasks:
task.delete()
return True
def set_all_inactive(self):
conectors = WorkFlow.view("couchflow/flowconector", include_docs=True)
conectors = conectors[self._id]
# TODO: bulk save
for conector in conectors:
conector.active = False
conector.save()
tasks = Task.view("couchflow/flowtask", include_docs=True)
tasks = tasks[self._id]
for task in tasks:
task.finish_task(None)
task.save()
return True
def get_docs(self):
documents = WorkFlow.view("couchflow/flowdocs", include_docs=True)
documents = documents[self._id]
documents = documents.all()
documents.reverse()
return documents
def set_enabled(self):
tasks = Task.view("couchflow/flowtask", include_docs=True)
tasks = tasks[self._id]
flag = True
for task in tasks:
task.enabled = flag
task.save()
return True
def set_disabled(self):
tasks = Task.view("couchflow/flowtask", include_docs=True)
tasks = tasks[self._id]
flag = True
for task in tasks:
task.enabled = flag
task.save()
return True
def get_first_conector(self):
conectors = WorkFlow.view("couchflow/firstconector", include_docs=True)
conectors = conectors[self._id]
return conectors.one()
def get_active_tasks(self):
tasks = Task.view("couchflow/activetask", include_docs=True)
tasks = tasks[self._id]
return tasks
def conector_tasks(self, conector):
if len(conector.next_tasks) > 0:
tasks = []
# TODO: use bulk api to get tasks
if not conector.doc_type == "UntilConector":
for task_id in conector.next_tasks:
task = Task.get(task_id)
tasks.append(task)
else:
task = Task.get(conector.next_tasks[0])
tasks.append(task)
return tasks
return False
def tasks_conectors(self, tasks):
conectors = []
for task in tasks:
if task.conector_id:
conector = get_conector(task.conector_id)
#if conector.doc_type == "SequenceConector" and
#conector.active:
# sequence_conector = SequenceConector.get(conector._id)
conectors.append(conector)
if len(conectors) > 0:
return conectors
return False
def tasks_tree(self):
first_conector = self.get_first_conector()
tasks_tree = [
[first_conector],
]
tasks = self.conector_tasks(first_conector)
while tasks:
tasks_tree.append(tasks)
conectors = self.tasks_conectors(tasks)
if conectors:
tasks_tree.append(conectors)
tasks = []
for conector in conectors:
try:
tasks += self.conector_tasks(conector)
except:
pass
else:
tasks = False
if len(tasks_tree) > 1:
return tasks_tree
return False
def add_conector(self, conector, active=False):
self.conectors[conector._id] = active
self.save()
return True
def add_task(self, task, active=False):
self.tasks[task._id] = active
self.save()
return True
def remove_tree(self, task):
return True
class Task(Document):
_db = get_db("couchflow")
name = schema.StringProperty()
task_type = schema.BooleanProperty(default=True)
item_type = schema.StringProperty()
node_type = schema.StringProperty(default="default")
workflow_id = schema.StringProperty()
workflow_type = schema.StringProperty()
workflow_nro = schema.IntegerProperty(default=0)
comments = schema.StringProperty()
wfitems_ids = schema.ListProperty()
conector_id = schema.StringProperty(default=None)
user_id = schema.StringProperty(default=None)
saved_by = schema.StringProperty(default=None)
group_id = schema.StringProperty(default=None)
prev_conector_id = schema.StringProperty(default=None)
is_clone = schema.BooleanProperty(default=False)
item_fields = schema.DictProperty()
item_required_fields = schema.DictProperty()
item_tema3_fields = schema.DictProperty()
end = schema.BooleanProperty(default=False)
step = schema.IntegerProperty(default=0)
active = schema.BooleanProperty()
have_until = schema.BooleanProperty(default=False)
enabled = schema.BooleanProperty(default=False)
status = schema.StringProperty()
position = schema.DictProperty(default={'x': 50, 'y': 50})
get_id = property(lambda self: self['_id'])
# text shown in the task
description = schema.StringProperty()
group_by_urn = schema.BooleanProperty(default=False)
visible = schema.BooleanProperty(default=True)
# template used to display tasks, if exists
html_tpl = schema.StringProperty(default="")
# Used in loader
base_item = schema.StringProperty()
def is_bulkable(self):
for i in self.item_fields:
if self.item_fields[i] == 'write':
return False
return True
def exec_process(self):
return True
@property
def item_name(self):
name = ''
try:
item = self.get_item(json=True)
field = item['fields_properties']['245']['list'][0]
name = field['subfields']['a']['exec_value'][0]
except Exception, error:
print 'Cant get item_name', error
try:
item = self.get_item(json=True)
field = item['fields_properties']['700']['list'][0]
name = field['subfields']['a']['exec_value'][0]
except Exception, error:
print ' Cant get item_name', error
class User(Document):
_db = get_db("couchauth")
get_id = property(lambda self: self['_id'])
first_name = schema.StringProperty(required=False)
last_name = schema.StringProperty(required=False)
email = schema.StringProperty(required=False)
document_type = schema.StringProperty(required=False)
document_number = schema.IntegerProperty(required=False)
address = schema.StringProperty(required=False)
phone_number = schema.StringProperty(required=False)
cellphone_number = schema.StringProperty(required=False)
comment = schema.StringProperty(required=False)
username = schema.StringProperty()
password = schema.StringProperty()
groups = schema.ListProperty()
is_staff = schema.BooleanProperty()
is_superuser = schema.BooleanProperty(default=False)
is_active = schema.BooleanProperty(default=True)
last_login = schema.DateTimeProperty(required=False)
date_joined = schema.DateTimeProperty(default=datetime.utcnow)
penalties = schema.SchemaListProperty(Penalty)
tematres_host = schema.StringProperty(required=False)
def del_group(self, group_id):
group = Group.get(group_id)
group.del_user(self._id)
if group_id in self.groups:
del (self.groups[self.groups.index(group_id)])
self.save()
def add_group(self, group_id):
group = Group.get(group_id)
group.add_user(self._id)
if group_id not in self.groups:
self.groups.append(group_id)
self.save()
def update_groups(self, groups):
for group_id in self.groups:
if group_id not in groups:
self.del_group(group_id)
for group_id in groups:
self.add_group(group_id)
def id(self):
return self._id
def set_password(self, password_string):
self.password = encrypt_value(password_string)
return True
def check_password(self, password_string):
if self.password == encrypt_value(password_string):
return True
return False
@classmethod
def get_user(cls, username, is_active=True):
param = {"key": username}
user = cls.view('couchauth/username', include_docs=True,
**param).first()
if user and user.is_active:
return user
return None
@classmethod
def get_user_with_groups(cls, username):
db = cls.get_db()
rows = list(
db.view('couchauth/user_and_groups',
include_docs=True,
startkey=[username, 0],
endkey=[username, 1]).all())
if rows:
user = cls.wrap(rows[0]['doc'])
user.group_names = [x['doc']['name'] for x in rows[1:]]
return user
@classmethod
def get_user_by_email(cls, email, is_active=True):
param = {"key": email}
user = cls.view('couchauth/get_by_email', include_docs=True,
**param).first()
if user and user.is_active:
return user
return None
def __unicode__(self):
return self.username
def __repr__(self):
return "<User: %s>" % self.username
def is_anonymous(self):
return False
def save(self):
if not self.check_username():
raise Exception('This username is already in use.')
if not self.check_email():
raise Exception('This email address is already in use.')
return super(self.__class__, self).save()
def check_username(self):
user = User.get_user(self.username, is_active=None)
if user is None:
return True
return user._id == self._id
def check_email(self):
if not self.email:
return True
user = User.get_user_by_email(self.email, is_active=None)
if user is None:
return True
return user._id == self._id
def _get_id(self):
return self.username
id = property(_get_id)
def is_authenticated(self):
return True