Produits Entr'ouvert » Calebasse

from calebasse.ressources.models import ServiceLinkedAbstractModel

from ..middleware.request import get_request

class ActValidationState(models.Model):

    class Meta:

                act=act,state_name='NON_VALIDE',

                author=author, previous_state=None)

        act.last_validation_state = last_validation_state

        act.save()

        return act

            self.valide = True

        else:

            self.valide = False

        self.save()

    def is_billable(self):

    def save(self, *args, **kwargs):

        if self.parent_event and not self.parent_event.canceled:

            super(Act, self).save(*args, **kwargs)

    def duration(self):

        '''Return a displayable duration for this field.'''

            pass

        return None

    class Meta:

        verbose_name = u"Acte"

        verbose_name_plural = u"Actes"

    def get_context_data(self, **kwargs):

        ctx = super(ActListingView, self).get_context_data(**kwargs)

        ctx['search_form'] = self.search_form

        return ctx

class NewAct(NewAppointmentView):

    def form_valid(self, form):

        result = super(NewAct, self).form_valid(form)

        self.object.act.save()

        return result

act_listing = ActListingView.as_view()

        if self.object.event:

            self.object.event.delete()

        if not self.object.is_billed:

            self.object.delete()

        return HttpResponse(status=204)

            self.object.event.participants =  doctors

            self.object.event.act_type =  self.object.act_type

            self.object.event.save()

        return result

update_act = UpdateActView.as_view()

        act.is_billed = False

        act.healthcare = None

        act.save()

        return super(RebillActView, self).post(request, *args, **kwarg)

rebill_act = RebillActView.as_view()

                'start_datetime': forms.HiddenInput,

        }

    def __init__(self, instance, service=None, **kwargs):

        self.service = None

        super(NewAppointmentForm, self).__init__(instance=instance, **kwargs)

            if commit:

                appointment.patient = patient

                appointment.save()

                self.save_m2m()

                appointment.services = [self.service]

        appointment.clean()

        if commit:

            appointment.save()

            self.save_m2m()

            appointment.services = [self.service]

        return appointment

        event.clean()

        if commit:

            event.save()

            event.services = [self.service]

        return event

from calebasse.agenda import managers

from calebasse.utils import weeks_since_epoch, weekday_ranks

from calebasse.personnes.models import Holiday

from interval import Interval

__all__ = (

        assert self.start_datetime is not None

        self.sanitize() # init periodicity fields

        super(Event, self).save(*args, **kwargs)

        self.acts_cleaning()

    def delete(self, *args, **kwargs):

    def update_act(self, act):

        '''Update an act to match details of the meeting'''

        self.init_act(act)

        act.save()

    def init_act(self, act):

        '''Force event_type to be patient meeting.'''

        self.event_type = EventType(id=1)

        super(EventWithAct, self).save(*args, **kwargs)

    def is_event_absence(self):

        return self.act.is_absent()

        messages.add_message(self.request, messages.INFO, u'Evénement enregistré avec succès.')

        return super(NewEventView, self).form_valid(form)

class BaseEventView(UpdateView):

    model = Event

    form_class = UpdateEventForm

        NamedAbstractModel)

from calebasse.actes.models import Act

DEFAULT_ACT_NUMBER_DIAGNOSTIC = 6

DEFAULT_ACT_NUMBER_TREATMENT = 30

DEFAULT_ACT_NUMBER_PROLONGATION = 10

                datetime(self.date_selected.year,

                        self.date_selected.month, self.date_selected.day)

        super(FileState, self).save(**kwargs)

    def __unicode__(self):

        return self.status.name + ' ' + str(self.date_selected)

        if self.patient.last_state == self:

            self.patient.last_state = self.previous_state

            self.patient.save()

        super(FileState, self).delete(*args, **kwargs)

class PatientAddress(models.Model):

        if self.city:

            self.display_name += self.city + ' '

        super(PatientAddress, self).save(**kwargs)

class PatientContact(People):

    class Meta:

        if not getattr(self, 'service', None):

            raise Exception('The field service is mandatory.')

        super(PatientRecord, self).save(*args, **kwargs)

    def get_state(self):

        return self.last_state

    def delete(self, *args, **kwargs):

        if self.can_be_deleted():

            super(PatientRecord, self).delete(*args, **kwargs)

    def get_ondisk_directory(self, service):

        if not settings.PATIENT_FILES_BASE_DIRECTORY:

    patient.save()

    patient.policyholder = patient.patientcontact

    patient.save()

    return patient

from model_utils import Choices

from model_utils.managers import PassThroughManager

class Role(NamedAbstractModel):

    users = models.ManyToManyField(User,

                verbose_name=u'Utilisateurs', blank=True)

        else:

            self.display_name = self.last_name.upper()

        super(People, self).save(**kwargs)

    def __unicode__(self):

        return self.display_name

        if not self.initials:

            self.initials = self.get_initials()

        super(Worker, self).save(**kwargs)

    def is_active(self):

        return self.enabled

    'reversion.middleware.RevisionMiddleware',

    # Entr'ouvert wsgi middleware to expose version

    'entrouvert.djommon.middleware.VersionMiddleware',

)

ROOT_URLCONF = 'calebasse.urls'

    'calebasse.statistics',

    'calebasse.middleware.request',

    'south',

)

INTERNAL_IPS=('127.0.0.1',)