cubicweb: comparison server/migractions.py

equal deleted inserted replaced

-:caef98aa4a98
+:59220b704562
 def backup_database(self, backupfile=None, askconfirm=True):
 config = self.config
 repo = self.repo_connect()
 # paths
-timestamp = datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
+timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
 instbkdir = osp.join(config.appdatahome, 'backup')
 if not osp.exists(instbkdir):
 os.makedirs(instbkdir)
 backupfile = backupfile or osp.join(instbkdir, '%s-%s.tar.gz'
 % (config.appid, timestamp))
 return
 repospschema = repoeschema.specializes()
 espschema = eschema.specializes()
 if repospschema and not espschema:
 self.rqlexec('DELETE X specializes Y WHERE X is CWEType, X name %(x)s',
-{'x': str(repoeschema)})
+{'x': str(repoeschema)}, ask_confirm=False)
 elif not repospschema and espschema:
 self.rqlexec('SET X specializes Y WHERE X is CWEType, X name %(x)s, '
 'Y is CWEType, Y name %(y)s',
-{'x': str(repoeschema), 'y': str(espschema)})
+{'x': str(repoeschema), 'y': str(espschema)},
+ask_confirm=False)
 self.rqlexecall(ss.updateeschema2rql(eschema),
 ask_confirm=self.verbosity >= 2)
 for rschema, targettypes, role in eschema.relation_definitions(True):
 if role == 'subject':
 if not rschema in repoeschema.subject_relations():
 def cmd_synchronize_permissions(self, ertype, commit=True):
 self.cmd_sync_schema_props_perms(ertype, syncprops=False, commit=commit)
 # Workflows handling ######################################################
+def cmd_add_workflow(self, name, wfof, default=True, commit=False,
+**kwargs):
+self.session.set_pool() # ensure pool is set
+wf = self.cmd_create_entity('Workflow', name=unicode(name),
+**kwargs)
+if not isinstance(wfof, (list, tuple)):
+wfof = (wfof,)
+for etype in wfof:
+rset = self.rqlexec(
+'SET X workflow_of ET WHERE X eid %(x)s, ET name %(et)s',
+{'x': wf.eid, 'et': etype}, 'x', ask_confirm=False)
+assert rset, 'unexistant entity type %s' % etype
+if default:
+self.rqlexec(
+'SET ET default_workflow X WHERE X eid %(x)s, ET name %(et)s',
+{'x': wf.eid, 'et': etype}, 'x', ask_confirm=False)
+if commit:
+self.commit()
+return wf
+# XXX remove once cmd_add_[state|transition] are removed
+def _get_or_create_wf(self, etypes):
+self.session.set_pool() # ensure pool is set
+if not isinstance(etypes, (list, tuple)):
+etypes = (etypes,)
+rset = self.rqlexec('Workflow X WHERE X workflow_of ET, ET name %(et)s',
+{'et': etypes[0]})
+if rset:
+return rset.get_entity(0, 0)
+return self.cmd_add_workflow('%s workflow' % ';'.join(etypes), etypes)
+@deprecated('use add_workflow and Workflow.add_state method')
 def cmd_add_state(self, name, stateof, initial=False, commit=False, **kwargs):
 """method to ease workflow definition: add a state for one or more
 entity type(s)
 """
-stateeid = self.cmd_add_entity('State', name=name, **kwargs)
+wf = self._get_or_create_wf(stateof)
-if not isinstance(stateof, (list, tuple)):
+state = wf.add_state(name, initial, **kwargs)
-stateof = (stateof,)
+if commit:
-for etype in stateof:
+self.commit()
-# XXX ensure etype validity
+return state.eid
-self.rqlexec('SET X state_of Y WHERE X eid %(x)s, Y name %(et)s',
-{'x': stateeid, 'et': etype}, 'x', ask_confirm=False)
+@deprecated('use add_workflow and Workflow.add_transition method')
-if initial:
-self.rqlexec('SET ET initial_state S WHERE ET name %(et)s, S eid %(x)s',
-{'x': stateeid, 'et': etype}, 'x', ask_confirm=False)
-if commit:
-self.commit()
-return stateeid
 def cmd_add_transition(self, name, transitionof, fromstates, tostate,
 requiredgroups=(), conditions=(), commit=False, **kwargs):
 """method to ease workflow definition: add a transition for one or more
 entity type(s), from one or more state and to a single state
 """
-treid = self.cmd_add_entity('Transition', name=name, **kwargs)
+wf = self._get_or_create_wf(transitionof)
-if not isinstance(transitionof, (list, tuple)):
+tr = wf.add_transition(name, fromstates, tostate, requiredgroups,
-transitionof = (transitionof,)
+conditions, **kwargs)
-for etype in transitionof:
+if commit:
-# XXX ensure etype validity
+self.commit()
-self.rqlexec('SET X transition_of Y WHERE X eid %(x)s, Y name %(et)s',
+return tr.eid
-{'x': treid, 'et': etype}, 'x', ask_confirm=False)
-for stateeid in fromstates:
+@deprecated('use Transition.set_transition_permissions method')
-self.rqlexec('SET X allowed_transition Y WHERE X eid %(x)s, Y eid %(y)s',
-{'x': stateeid, 'y': treid}, 'x', ask_confirm=False)
-self.rqlexec('SET X destination_state Y WHERE X eid %(x)s, Y eid %(y)s',
-{'x': treid, 'y': tostate}, 'x', ask_confirm=False)
-self.cmd_set_transition_permissions(treid, requiredgroups, conditions,
-reset=False)
-if commit:
-self.commit()
-return treid
 def cmd_set_transition_permissions(self, treid,
 requiredgroups=(), conditions=(),
 reset=True, commit=False):
 """set or add (if `reset` is False) groups and conditions for a
 transition
 """
-if reset:
+self.session.set_pool() # ensure pool is set
-self.rqlexec('DELETE T require_group G WHERE T eid %(x)s',
+tr = self.session.entity_from_eid(treid)
-{'x': treid}, 'x', ask_confirm=False)
+tr.set_transition_permissions(requiredgroups, conditions, reset)
-self.rqlexec('DELETE T condition R WHERE T eid %(x)s',
+if commit:
-{'x': treid}, 'x', ask_confirm=False)
+self.commit()
-for gname in requiredgroups:
-### XXX ensure gname validity
+@deprecated('use entity.fire_transition("transition") or entity.change_state("state")')
-self.rqlexec('SET T require_group G WHERE T eid %(x)s, G name %(gn)s',
-{'x': treid, 'gn': gname}, 'x', ask_confirm=False)
-if isinstance(conditions, basestring):
-conditions = (conditions,)
-for expr in conditions:
-if isinstance(expr, str):
-expr = unicode(expr)
-self.rqlexec('INSERT RQLExpression X: X exprtype "ERQLExpression", '
-'X expression %(expr)s, T condition X '
-'WHERE T eid %(x)s',
-{'x': treid, 'expr': expr}, 'x', ask_confirm=False)
-if commit:
-self.commit()
 def cmd_set_state(self, eid, statename, commit=False):
 self.session.set_pool() # ensure pool is set
-entity = self.session.entity_from_eid(eid)
+self.session.entity_from_eid(eid).change_state(statename)
-entity.change_state(entity.wf_state(statename).eid)
 if commit:
 self.commit()
 # CWProperty handling ######################################################
 value = unicode(value)
 try:
 prop = self.rqlexec('CWProperty X WHERE X pkey %(k)s', {'k': pkey},
 ask_confirm=False).get_entity(0, 0)
 except:
-self.cmd_add_entity('CWProperty', pkey=unicode(pkey), value=value)
+self.cmd_create_entity('CWProperty', pkey=unicode(pkey), value=value)
 else:
 self.rqlexec('SET X value %(v)s WHERE X pkey %(k)s',
 {'k': pkey, 'v': value}, ask_confirm=False)
 # other data migration commands ###########################################
+def cmd_create_entity(self, etype, *args, **kwargs):
+"""add a new entity of the given type"""
+commit = kwargs.pop('commit', False)
+self.session.set_pool()
+entity = self.session.create_entity(etype, *args, **kwargs)
+if commit:
+self.commit()
+return entity
+@deprecated('use create_entity')
 def cmd_add_entity(self, etype, *args, **kwargs):
 """add a new entity of the given type"""
-rql = 'INSERT %s X' % etype
+return self.cmd_create_entity(etype, *args, **kwargs).eid
-relations = []
-restrictions = []
-for rtype, rvar in args:
-relations.append('X %s %s' % (rtype, rvar))
-restrictions.append('%s eid %s' % (rvar, kwargs.pop(rvar)))
-commit = kwargs.pop('commit', False)
-for attr in kwargs:
-relations.append('X %s %%(%s)s' % (attr, attr))
-if relations:
-rql = '%s: %s' % (rql, ', '.join(relations))
-if restrictions:
-rql = '%s WHERE %s' % (rql, ', '.join(restrictions))
-eid = self.rqlexec(rql, kwargs, ask_confirm=self.verbosity>=2).rows[0][0]
-if commit:
-self.commit()
-return eid
 def sqlexec(self, sql, args=None, ask_confirm=True):
 """execute the given sql if confirmed
 should only be used for low level stuff undoable with existing higher

branch	stable
changeset 3315	59220b704562
parent 3213	36a2357ccbc4
child 3230	1d25e928c299
child 3548	4cf5a360952e