def subscriptions(request):
group = get_last_used_group(request.user)
context = base_context(request, group.id)
try:
subscription = Subscription.objects.get(user=request.user)
except Subscription.DoesNotExist:
Subscription.subscribe_for_the_first_time(request.user, request.user)
subscription = Subscription.objects.get(user=request.user)
waiting_payment_subscriptions = Payment.objects.filter(created_by=request.user, status=WAITING).order_by(
"datetime_created"
)
subscriptions = Subscriptions.objects.filter(subscription=subscription).order_by("-datetime_created")
my_payments = Payment.objects.filter(
Q(status=PAID) | Q(status=NOT_ENOUGH_MONEY_ARRIVED) | Q(status=CANCELED), created_by=request.user
).order_by("-datetime_created")
previous = None
for wps in waiting_payment_subscriptions:
wps.other_users_included_in_payment = wps.other_users_included_in_payment(request.user)
wps.me_included = wps.me_included_in_payment(request.user)
if wps.me_included:
if not previous:
wps.start_date = subscription.expiration_date
wps.end_date = wps.start_date + datetime.timedelta(days=wps.subscription_duration * 31)
else:
wps.start_date = previous.end_date
wps.end_date = wps.start_date + datetime.timedelta(days=wps.subscription_duration * 31)
previous = wps
context["sepa_address"] = settings.PAYMENT["sepa"]
context["subscription"] = subscription
context["waiting_payment_subscriptions"] = waiting_payment_subscriptions
context["subscriptions"] = subscriptions
context["my_payments"] = my_payments
context["show_hide_canceled_button"] = False
context["user"] = request.user
context["subscription"] = Subscription.objects.get(user=request.user)
# 'others_included': None,
# 'past_subscriptions': past_subscriptions,
context["title"] = _("My subscriptions")
context["site_title"] = g.SITE_TITLE
context["section"] = "settings"
context["NOT_ENOUGH_MONEY_ARRIVED_STATUS"] = NOT_ENOUGH_MONEY_ARRIVED
context["NO_MONEY_ARRIVED_STATUS"] = NO_MONEY_ARRIVED
context["WAITING_STATUS"] = WAITING
context["CANCELED_STATUS"] = CANCELED
context["ALMOST_PAID_STATUS"] = ALMOST_PAID
context["PAID_STATUS"] = PAID
context["RUNNING_STATUS"] = RUNNING
return render(request, "subscription/subscriptions.html", context)
def xmpp_task(request):
subscription_keys = Subscription.all(keys_only=True).filter("activated_xmpp =", True)
# .filter("next_airtime <", datetime.datetime.now().date())
counter = 0
for key in subscription_keys:
Subscription.add_xmpp_task(key)
counter += 1
return HttpResponse("Done: added %d" % counter)
def webhook_task(request):
"""BadFilterError: invalid filter: Only one property per query may have inequality filters (<=, >=, <, >).."""
subscriptions = Subscription.all().filter("webhook !=", None)
counter = 0
for obj in subscriptions:
Subscription.add_webhook_task(obj.key())
counter += 1
return HttpResponse("Done: added %d" % counter)
def setUp(self):
subscriber = Subscription(
name='Joao Paulo Dubas',
cpf='12345678901',
email='*****@*****.**',
phone='11-12345678'
)
subscriber.save()
def email_task(request):
filter_date = datetime.datetime.now().date() + datetime.timedelta(days=1)
subscription_keys = Subscription.all(keys_only=True).filter("activated_mail =", True)\
.filter("next_airtime <=", filter_date)
counter = 0
for key in subscription_keys:
Subscription.add_email_task(key)
counter += 1
return HttpResponse("Done: added %d" % counter)
def base_context(request, company_id):
Subscription.is_subscription_almost_over(request.user)
Subscription.is_subscription_over(request.user)
actions = Action.objects.filter(status=g.WAITING, _for=request.user.email)
for a in actions:
if a.what == "invitation":
a.data = json.loads(a.data)
#if get_language() == "sl-si":
# accept_url = "sprejmi-povabilo-v-skupino/kljuc=%s" % (a.reference)
# decline_url = "zavrni-povabilo-v-skupino/kljuc=%s" % (a.reference)
# a.accept_url = settings.SITE_URL + settings.URL_PREFIX + accept_url
# a.decline_url = settings.SITE_URL + settings.URL_PREFIX + decline_url
#else:
accept_url = "accept-group-invitation/key=%s" % (a.reference)
decline_url = "decline-group-invitation/key=%s" % (a.reference)
a.accept_url = settings.SITE_URL + settings.URL_PREFIX + accept_url
a.decline_url = settings.SITE_URL + settings.URL_PREFIX + decline_url
# user_groups = request.user.get_user_groups()
"""
try:
user_profile = UserProfile.objects.get(user=request.user)
except UserProfile.DoesNotExist:
user_profile = None
"""""
context = {
'bluser': request.user,
# 'user_profile': user_profile,
'GOOGLE_API': settings.GOOGLE_API,
'actions': actions,
'subscription_link': reverse('subscription:new'),
# json values
# settings, config
'title': "", # will be overwritten by javascript
'language': get_user_value(request.user, "language"),
'clock_range': get_user_value(request.user, "clock_range"),
'site_title': g.SITE_TITLE,
'group_notes_keepalive': g.GROUP_NOTES_KEEPALIVE,
'date_format': g.DATE_FORMATS[get_user_value(request.user, 'date_format')]['jquery'] if request.user.is_authenticated() else g.DATE_FORMATS[g.DEFAULT_DATE_FORMAT]['jquery'],
'field_lengths': {
'max_notes_size': g.MAX_NOTES_SIZE,
}
}
return context
def test_send_email_after_save_form(self):
self.assertEqual(len(mail.outbox), 0)
subscriber = Subscription(
name='Joao Paulo Dubas',
cpf='12345678901',
email='*****@*****.**',
phone='11-12345678'
)
subscriber.save()
self.assertEqual(len(mail.outbox), 1)
def test_save_subscription(self):
subscriber = Subscription(
name='Joao Paulo Dubas',
cpf='12345678901',
email='*****@*****.**',
phone='11-12345678'
)
subscriber.save()
self.assertEqual(subscriber.pk, 1)
self.assertEqual(subscriber.created_at.date(), date.today())
self.assertFalse(subscriber.paid)
def get(self, request):
partnerId=request.GET.get("partnerId")
ipAddress=request.GET.get("ipAddress")
userIdentifier=request.GET.get("userIdentifier")
expDate = ""
subscribed = False
sub = Subscription.getActiveByIp(ipAddress, partnerId)
if len(sub)==0:
if Credential.objects.filter(userIdentifier=userIdentifier).filter(partnerId=partnerId).exists():
partyId = Credential.objects.filter(userIdentifier=userIdentifier)[0].partyId.partyId
sub = Subscription.getActiveById(partyId, partnerId)
if len(sub)>0:
expDate = SubscriptionSerializer(sub[0]).data['endDate']
subscribed = True
return HttpResponse(json.dumps({'expDate':expDate, 'subscribed':subscribed}), content_type="application/json")
def create(request):
form = SubscriptionForm(request.POST)
if not form.is_valid():
context = RequestContext(request, {'form': form})
return render_to_response('subscription/new.html', context)
subscription = Subscription()
subscription.name = form.cleaned_data['name']
subscription.cpf = form.cleaned_data['cpf']
subscription.email = form.cleaned_data['email']
subscription.phone = form.cleaned_data['phone']
subscription.save()
send_subscription_email(subscription)
return HttpResponseRedirect(reverse('subscription:success', args=[subscription.pk]))
def get_subscribed(self):
from subscription.models import Subscription
Subscription.subscribe_for_the_first_time(self, self)
Subscription.move_from_email_to_user(self)
try:
subscription = Subscription.objects.get(user=self)
except Subscription.DoesNotExist:
return False
if subscription.days_left > 0:
return True
return False
def get(self, request, format=None):
if 'ip' not in request.GET:
return Response({'error': 'ip is required'},status=status.HTTP_400_BAD_REQUEST)
if 'partnerId' not in request.GET:
return Response({'error': 'partnerId is required'}, status=status.HTTP_400_BAD_REQUEST)
ip = request.GET.get('ip')
partnerId = request.GET.get('partnerId')
ipranges = IpRange.getByIp(ip)
if len(ipranges) <1:
return HttpResponse("")
partyId = ipranges[0].partyId.partyId
party = Party.objects.get(partyId=partyId)
subscription = Subscription.getActiveById(partyId, partnerId)
status = None
if len(subscription) > 0:
status = 'subscribed'
else:
status = 'not subscribed'
ret = {
'name': party.name,
'status': status,
}
return HttpResponse(json.dumps(ret), content_type="application/json")
def show(request, subkey, extra_context=None):
subscription = Subscription.all().filter("subkey =", subkey).get()
if subscription is None:
raise Http404
if extra_context is None:
extra_context = {}
if "mail_form" in extra_context:
subscription.mail_form = extra_context["mail_form"]
else:
subscription.mail_form = MailSubscriptionForm({"email": subscription.email, "subkey": subkey})
if "xmpp_form" in extra_context:
subscription.xmpp_form = extra_context["xmpp_form"]
else:
subscription.xmpp_form = XMPPSubscriptionForm({"xmpp": subscription.xmpp, "subkey": subkey})
if "webhook_form" in extra_context:
subscription.webhook_form = extra_context["webhook_form"]
else:
subscription.webhook_form = WebHookSubscriptionForm({"webhook": subscription.webhook, "subkey": subkey})
if "public_id_form" in extra_context:
subscription.public_id_form = extra_context["public_id_form"]
else:
subscription.public_id_form = SubscriptionKeyForm({"subkey": subkey})
subscription.sub_settings = subscription.get_settings()
response = render_to_response("subscription.html", RequestContext(request,
{"shows": subscription.get_shows(), "subscription":subscription}))
response.set_cookie("subkey", subkey, max_age=31536000)
return response
def clean_subkey(self):
subkey = self.cleaned_data["subkey"]
sub = Subscription.all().filter("subkey =", subkey).get()
if sub is None:
raise forms.ValidationError("You don't have a valid Seriesly Subscription Key")
self._subscription = sub
return subkey
def get(self, request):
params = request.GET
if 'subscriptionId' in request.GET:
subscriptionId = request.GET.get('subscriptionId')
subscription = Subscription.objects.all().get(subscriptionId=subscriptionId)
serializer = SubscriptionSerializer(subscription)
return Response(serializer.data)
elif 'partyId' in params:
partyId = params['partyId']
now = datetime.datetime.now()
if 'checkConsortium' in params and params['checkConsortium'] == 'true':
partnerIdList = Partner.objects.all().values_list('partnerId', flat=True)
idSub = []
allSub = Subscription.getById(partyId)
for partnerId in partnerIdList:
if allSub.filter(partnerId=partnerId).filter(endDate__gt=now).filter(startDate__lt=now).exists():
idSub.append(allSub.filter(partnerId=partnerId).filter(endDate__gt=now).filter(startDate__lt=now).latest('endDate'))
serializer = SubscriptionSerializer(idSub, many=True)
elif 'active' in params and params['active'] == 'true':
activeSubscriptions = Subscription.objects.all().filter(partyId=partyId).filter(endDate__gt=now).filter(startDate__lt=now)
serializer = SubscriptionSerializer(activeSubscriptions, many=True)
else:
allSubscriptions = Subscription.objects.all().filter(partyId=partyId)
serializer = SubscriptionSerializer(allSubscriptions, many=True)
return Response(serializer.data, status=200)
elif all(param in params for param in ['partnerId', 'ipAddress', 'userIdentifier']):
partnerId = params['partnerId']
ipAddress = params['ipAddress']
userIdentifier = params['userIdentifier']
idSub = None #Pw-418
subList = [] #Pw-418
ipSub = Subscription.getByIp(ipAddress).filter(partnerId=partnerId)
if Credential.objects.filter(userIdentifier=userIdentifier).filter(partnerId=partnerId).exists():
partyId = Credential.objects.filter(partnerId=partnerId).filter(userIdentifier=userIdentifier)[0].partyId.partyId
idSub = Subscription.getById(partyId).filter(partnerId=partnerId)
if (idSub):
subList = SubscriptionSerializer(ipSub, many=True).data+SubscriptionSerializer(idSub, many=True).data
else:
subList = SubscriptionSerializer(ipSub, many=True).data
for sub in subList:
if Party.objects.filter(partyId = sub['partyId']).exists():
party = PartySerializer(Party.objects.get(partyId = sub['partyId'])).data
sub['partyType'] = party['partyType']
sub['name'] = party['name']
return HttpResponse(json.dumps(subList), content_type="application/json")
else:
return Response({"error":"Essential parameters needed."}, status=status.HTTP_400_BAD_REQUEST)
def json_public(request, public_id):
subscription = Subscription.all().filter("public_id =", public_id).get()
if subscription is None:
raise Http404
response = _guide(request, subscription, template="widget.json",
public=True, extra_context=get_extra_json_context(request))
response["Content-Type"] = 'application/json'
return response
def clean(self):
cleaned_data = self.cleaned_data
if cleaned_data["xmpp"] != "":
sub = Subscription.all().filter("xmpp =", cleaned_data["xmpp"]).filter("subkey !=", self._subscription.subkey).get()
if sub is not None:
self._errors["xmpp"] = forms.util.ErrorList(["This XMPP address already belongs to a subscription."])
del cleaned_data["xmpp"]
return cleaned_data
def subscriptions(request):
now = datetime.datetime.now()
threshold = now - datetime.timedelta(days=30*3)
subcount = 0
for subscription in Subscription.all():
if subscription.last_visited is not None and subscription.last_visited > threshold:
subcount += 1
return HttpResponse("Done: \n%d" % subcount)
def inscricao(request):
if request.method == 'POST':
form = SubscriptionForm(request.POST)
if form.is_valid():
subscription = Subscription()
subscription.nome = form.cleaned_data['nome']
subscription.cpf = form.cleaned_data['cpf']
subscription.email = form.cleaned_data['email']
subscription.fone = form.cleaned_data['fone']
subscription.save()
try:
send_mail(
subject = u'Inscrição no EventeX',
message = u'Obrigado por se inscrever no EventeX!',
from_email = '*****@*****.**',
recipient_list = [request.POST['email']],
)
except:
pass
return sucesso(request, subscription.pk)
# messages = (u'Inscrição realizada com sucesso;', u'Aguarde até que sua solicitação de cadastro seja aprovada')
# return render_to_response('index.html',{'messages':messages, 'subscription': subscription.pk}, context_instance=RequestContext(request))
else:
form = SubscriptionForm(initial={
'nome':'Entre com o seu nome',
'cpf':'Digite o seu CPF sem pontos',
'email': 'Informe o seu email',
'fone' : 'Qual seu telefone de contato?',
})
return render_to_response('subscription/subscription_form.html',{'form': form, 'title' : u'Preencha Sua Inscrição'}, context_instance=RequestContext(request))
def set_next_airtime(request):
key = None
key = request.POST.get("key", None)
if key is None:
raise Http404
subscription = Subscription.get(key)
subscription.next_airtime = datetime.date(2010,1,1)
subscription.put()
return HttpResponse("Done: %s" % key)
def feed(request, subkey, template):
subscription = Subscription.all().filter("subkey =", subkey).get()
if subscription is None:
raise Http404
body = _feed(request, subscription, template)
mimetype = "application/atom+xml"
if "rss" in template:
mimetype = "application/rss+xml"
return HttpResponse(body, mimetype=mimetype)
def edit_public_id(request):
form = SubscriptionKeyForm(request.POST)
if not form.is_valid():
return show(request, request.POST.get("subkey", ""), extra_context={"public_id_form":form})
subscription = form._subscription
if subscription.public_id is None:
subscription.public_id = Subscription.generate_key("public_id")
else:
subscription.public_id = None
subscription.put()
return HttpResponseRedirect(subscription.get_absolute_url() + "#public-urls")
def confirm_mail(request, subkey, confirmkey):
subscription = Subscription.all().filter("subkey =", subkey).get()
if subscription is None:
raise Http404
if subscription.check_confirmation_key(confirmkey):
if subscription.activated_mail == False and subscription.email != "":
subscription.activated_mail = True
subscription.put()
return HttpResponseRedirect(subscription.get_absolute_url() + "#email")
else:
raise Http404
def edit(request, subkey):
subscription = Subscription.all().filter("subkey =", subkey).get()
if subscription is None:
raise Http404
if request.method == "GET":
sub_settings = subscription.get_settings()
sub_dict = {"email": subscription.email,
"shows": map(lambda x: x.idnr, subscription.get_shows()),
"subkey": subkey}
form = SubscriptionForm(sub_dict)
return index(request, form=form, extra_context={"subscription": subscription})
return HttpResponseRedirect(subscription.get_absolute_url())
def get(self,request):
params = request.GET
partnerId = params['partnerId']
ipAddress = params['ipAddress']
userIdentifier = params['userIdentifier']
idSub = None #Pw-418
subList = [] #Pw-418
ipSub = Subscription.getActiveByIp(ipAddress, partnerId)
if Credential.objects.filter(userIdentifier=userIdentifier).filter(partnerId=partnerId).exists():
partyId = Credential.objects.filter(partnerId=partnerId).filter(userIdentifier=userIdentifier)[0].partyId.partyId
idSub = Subscription.getActiveById(partyId, partnerId)
if (idSub):
subList = SubscriptionSerializer(ipSub, many=True).data+SubscriptionSerializer(idSub, many=True).data
else:
subList = SubscriptionSerializer(ipSub, many=True).data
for sub in subList:
if Party.objects.filter(partyId = sub['partyId']).exists():
party = PartySerializer(Party.objects.get(partyId = sub['partyId'])).data
sub['partyType'] = party['partyType']
sub['name'] = party['name']
return HttpResponse(json.dumps(subList), content_type="application/json")
def send_confirm_mail(request):
key = None
try:
key = request.POST.get("key", None)
if key is None:
raise Http404
subscription = Subscription.get(key)
if subscription is None:
raise Http404
except Exception, e:
logging.error(e)
return HttpResponse("Done (with errors): %s" % key)
def get(self, request):
partnerId=request.GET.get("partnerId")
if 'ipAddress' in request.GET:
ipAddress=request.GET.get("ipAddress")
else:
ipAddress=getRemoteIpAddress(request)
partyId = None
if 'partyId' in request.GET:
partyId = request.GET.get('partyId')
elif 'userIdentifier' in request.GET:
userIdentifier=request.GET.get("userIdentifier")
else:
return Response({'error':'partyId or userIdentifier is required'}, status=status.HTTP_400_BAD_REQUEST)
expDate = ""
subscribed = False
ipSub = Subscription.getActiveByIp(ipAddress, partnerId)
idSub = None #Pw-418
subList = [] #Pw-418
subscriptionType = None
if not partyId:
if Credential.objects.filter(userIdentifier=userIdentifier).filter(partnerId=partnerId).exists():
partyId = Credential.objects.filter(partnerId=partnerId).filter(userIdentifier=userIdentifier)[0].partyId.partyId
idSub = Subscription.getActiveById(partyId, partnerId)
else:
try:
idSub = Subscription.getActiveById(partyId, partnerId)
except:
return Response({'error':'getting active susbcription by id failed'}, status=status.HTTP_400_BAD_REQUEST)
if (idSub):
subList = SubscriptionSerializer(ipSub, many=True).data+SubscriptionSerializer(idSub, many=True).data
else:
subList = SubscriptionSerializer(ipSub, many=True).data
if subList != []:
subscribed = True
expDate = max(sub['endDate'] for sub in subList)
if ipSub:
subscriptionType = 'institutional'
elif idSub:
subscriptionType = 'individual'
return HttpResponse(json.dumps({'expDate':expDate, 'subscribed':subscribed, 'subscriptionType':subscriptionType}), content_type="application/json")
def post(self, request, *args, **kwargs):
list_id = kwargs.get('list_id', None)
email = request.POST.get('email', None)
name = request.POST.get('name', None)
action = request.POST.get('action', None)
channel = request.POST.get('channel', 'general')
valid = True
message = ''
if not (action and list_id):
valid = False
message = _(u'Incomplete form')
try:
validate_email(email)
except forms.ValidationError as e:
valid = False
message = u'Invalid e-mail address'
if valid:
newsletter = Newsletter.objects.get(id=list_id)
subscription = Subscription.objects.filter(newsletter=newsletter, email=email.strip())
if action == 'subscribe':
if subscription.exists() and not subscription[0].opted_out:
message = u'You are already subscribed to this newsletter'
elif subscription.exists():
subscription[0].opted_out = None
subscription[0].save()
subscription[0].subscribe()
message = u'Subscription updated'
else:
subscription = Subscription(
newsletter=newsletter,
email=email,
name=name,
language=get_language()[0:2],
channel=channel
)
subscription.save()
subscription.update_subscription()
message = u'You\'ve successfully signed-up for the newsletter. Soon you will receive an email to confirm your subscription.'
if action == 'unsubscribe':
if subscription.exists():
subscription[0].opted_out = False
subscription[0].save()
subscription[0].unsubscribe()
return self.render_json_response(
{
'success': valid,
'message': message,
})
def show_public(request, public_id):
subscription = Subscription.all().filter("public_id =", public_id).get()
if subscription is None:
raise Http404
response = render_to_response("subscription_public.html",
RequestContext(
request,
{
"shows": subscription.get_shows(),
"subscription": subscription
}
))
return response
def feed_atom_public(request, public_id, template="atom_public.xml"):
subscription = Subscription.all().filter("public_id =", public_id).get()
if subscription is None:
raise Http404
now = datetime.datetime.now()
if subscription.needs_update(subscription.feed_public_stamp, now):
subscription.check_beacon_status(now)
# don't specify encoding for unicode strings!
subscription.feed_public_cache = db.Text(_feed(request, subscription, template, public=True))
subscription.feed_public_stamp = now
try:
subscription.put() # this put is not highly relevant
except Exception, e:
logging.warning(e)
def handle(self, *args, **options):
os.environ["DJANGO_COLORS"] = "nocolor"
Site(id=4000, domain=settings.SITH_URL, name=settings.SITH_NAME).save()
root_path = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
Group(name="Root").save()
Group(name="Public").save()
Group(name="Subscribers").save()
Group(name="Old subscribers").save()
Group(name="Accounting admin").save()
Group(name="Communication admin").save()
Group(name="Counter admin").save()
Group(name="Banned from buying alcohol").save()
Group(name="Banned from counters").save()
Group(name="Banned to subscribe").save()
Group(name="SAS admin").save()
Group(name="Forum admin").save()
Group(name="Pedagogy admin").save()
self.reset_index("core", "auth")
root = User(
id=0,
username="******",
last_name="",
first_name="Bibou",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=True,
is_staff=True,
)
root.set_password("plop")
root.save()
profiles_root = SithFile(parent=None,
name="profiles",
is_folder=True,
owner=root)
profiles_root.save()
home_root = SithFile(parent=None,
name="users",
is_folder=True,
owner=root)
home_root.save()
# Page needed for club creation
p = Page(name=settings.SITH_CLUB_ROOT_PAGE)
p.set_lock(root)
p.save()
club_root = SithFile(parent=None,
name="clubs",
is_folder=True,
owner=root)
club_root.save()
SithFile(parent=None, name="SAS", is_folder=True, owner=root).save()
main_club = Club(
id=1,
name=settings.SITH_MAIN_CLUB["name"],
unix_name=settings.SITH_MAIN_CLUB["unix_name"],
address=settings.SITH_MAIN_CLUB["address"],
)
main_club.save()
bar_club = Club(
id=2,
name=settings.SITH_BAR_MANAGER["name"],
unix_name=settings.SITH_BAR_MANAGER["unix_name"],
address=settings.SITH_BAR_MANAGER["address"],
)
bar_club.save()
launderette_club = Club(
id=84,
name=settings.SITH_LAUNDERETTE_MANAGER["name"],
unix_name=settings.SITH_LAUNDERETTE_MANAGER["unix_name"],
address=settings.SITH_LAUNDERETTE_MANAGER["address"],
)
launderette_club.save()
self.reset_index("club")
for b in settings.SITH_COUNTER_BARS:
g = Group(name=b[1] + " admin")
g.save()
c = Counter(id=b[0], name=b[1], club=bar_club, type="BAR")
c.save()
g.editable_counters.add(c)
g.save()
self.reset_index("counter")
Counter(name="Eboutic", club=main_club, type="EBOUTIC").save()
Counter(name="AE", club=main_club, type="OFFICE").save()
home_root.view_groups.set([
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first()
])
club_root.view_groups.set([
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first()
])
home_root.save()
club_root.save()
Sith(weekmail_destinations="[email protected] [email protected]").save()
Weekmail().save()
p = Page(name="Index")
p.set_lock(root)
p.save()
p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
p.set_lock(root)
p.save()
PageRev(
page=p,
title="Wiki index",
author=root,
content="""
Welcome to the wiki page!
""",
).save()
p = Page(name="services")
p.set_lock(root)
p.save()
p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
p.set_lock(root)
PageRev(
page=p,
title="Services",
author=root,
content="""
| | | |
| :---: | :---: | :---: | :---: |
| [Eboutic](/eboutic) | [Laverie](/launderette) | Matmat | [Fichiers](/file) |
| SAS | Weekmail | Forum | |
""",
).save()
p = Page(name="launderette")
p.set_lock(root)
p.save()
p.set_lock(root)
PageRev(page=p,
title="Laverie",
author=root,
content="Fonctionnement de la laverie").save()
# Here we add a lot of test datas, that are not necessary for the Sith, but that provide a basic development environment
if not options["prod"]:
# Adding user Skia
skia = User(
username="******",
last_name="Kia",
first_name="S'",
email="*****@*****.**",
date_of_birth="1942-06-12",
)
skia.set_password("plop")
skia.save()
skia.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
skia.save()
skia_profile_path = os.path.join(root_path,
"core/fixtures/images/3.jpg")
with open(skia_profile_path, "rb") as f:
name = str(skia.id) + "_profile.jpg"
skia_profile = SithFile(
parent=profiles_root,
name=name,
file=resize_image(Image.open(BytesIO(f.read())), 400,
"JPEG"),
owner=skia,
is_folder=False,
mime_type="image/jpeg",
size=os.path.getsize(skia_profile_path),
)
skia_profile.file.name = name
skia_profile.save()
skia.profile_pict = skia_profile
skia.save()
# Adding user public
public = User(
username="******",
last_name="Not subscribed",
first_name="Public",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=False,
is_staff=False,
)
public.set_password("plop")
public.save()
public.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
public.save()
# Adding user Subscriber
subscriber = User(
username="******",
last_name="User",
first_name="Subscribed",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=False,
is_staff=False,
)
subscriber.set_password("plop")
subscriber.save()
subscriber.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
subscriber.save()
# Adding user old Subscriber
old_subscriber = User(
username="******",
last_name="Subscriber",
first_name="Old",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=False,
is_staff=False,
)
old_subscriber.set_password("plop")
old_subscriber.save()
old_subscriber.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
old_subscriber.save()
# Adding user Counter admin
counter = User(
username="******",
last_name="Ter",
first_name="Coun",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=False,
is_staff=False,
)
counter.set_password("plop")
counter.save()
counter.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
counter.groups.set([
Group.objects.filter(
id=settings.SITH_GROUP_COUNTER_ADMIN_ID).first().id
])
counter.save()
# Adding user Comptable
comptable = User(
username="******",
last_name="Able",
first_name="Compte",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=False,
is_staff=False,
)
comptable.set_password("plop")
comptable.save()
comptable.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
comptable.groups.set([
Group.objects.filter(
id=settings.SITH_GROUP_ACCOUNTING_ADMIN_ID).first().id
])
comptable.save()
# Adding user Guy
u = User(
username="******",
last_name="Carlier",
first_name="Guy",
email="*****@*****.**",
date_of_birth="1942-06-12",
is_superuser=False,
is_staff=False,
)
u.set_password("plop")
u.save()
u.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
u.save()
# Adding user Richard Batsbak
r = User(
username="******",
last_name="Batsbak",
first_name="Richard",
email="*****@*****.**",
date_of_birth="1982-06-12",
)
r.set_password("plop")
r.save()
r.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
r.save()
# Adding syntax help page
p = Page(name="Aide_sur_la_syntaxe")
p.save(force_lock=True)
with open(os.path.join(root_path) + "/doc/SYNTAX.md", "r") as rm:
PageRev(page=p,
title="Aide sur la syntaxe",
author=skia,
content=rm.read()).save()
p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
p.save(force_lock=True)
p = Page(name="Services")
p.save(force_lock=True)
p.view_groups.set([settings.SITH_GROUP_PUBLIC_ID])
p.save(force_lock=True)
PageRev(
page=p,
title="Services",
author=skia,
content="""
| | | |
| :---: | :---: | :---: |
| [Eboutic](/eboutic) | [Laverie](/launderette) | Matmat |
| SAS | Weekmail | Forum|
""",
).save()
# Subscription
default_subscription = "un-semestre"
# Root
s = Subscription(
member=User.objects.filter(pk=root.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Skia
s = Subscription(
member=User.objects.filter(pk=skia.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Counter admin
s = Subscription(
member=User.objects.filter(pk=counter.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Comptable
s = Subscription(
member=User.objects.filter(pk=comptable.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Richard
s = Subscription(
member=User.objects.filter(pk=r.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# User
s = Subscription(
member=User.objects.filter(pk=subscriber.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Old subscriber
s = Subscription(
member=User.objects.filter(pk=old_subscriber.pk).first(),
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start(
datetime(year=2012, month=9, day=4))
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Clubs
Club(
name="Bibo'UT",
unix_name="bibout",
address="46 de la Boustifaille",
parent=main_club,
).save()
guyut = Club(
name="Guy'UT",
unix_name="guyut",
address="42 de la Boustifaille",
parent=main_club,
)
guyut.save()
Club(name="Woenzel'UT",
unix_name="woenzel",
address="Woenzel",
parent=guyut).save()
Membership(user=skia, club=main_club, role=3,
description="").save()
troll = Club(
name="Troll Penché",
unix_name="troll",
address="Terre Du Milieu",
parent=main_club,
)
troll.save()
refound = Club(
name="Carte AE",
unix_name="carte_ae",
address="Jamais imprimée",
parent=main_club,
)
refound.save()
# Counters
Customer(user=skia, account_id="6568j", amount=0).save()
Customer(user=r, account_id="4000k", amount=0).save()
p = ProductType(name="Bières bouteilles")
p.save()
c = ProductType(name="Cotisations")
c.save()
r = ProductType(name="Rechargements")
r.save()
verre = ProductType(name="Verre")
verre.save()
cotis = Product(
name="Cotis 1 semestre",
code="1SCOTIZ",
product_type=c,
purchase_price="15",
selling_price="15",
special_selling_price="15",
club=main_club,
)
cotis.save()
cotis2 = Product(
name="Cotis 2 semestres",
code="2SCOTIZ",
product_type=c,
purchase_price="28",
selling_price="28",
special_selling_price="28",
club=main_club,
)
cotis2.save()
refill = Product(
name="Rechargement 15 €",
code="15REFILL",
product_type=r,
purchase_price="15",
selling_price="15",
special_selling_price="15",
club=main_club,
)
refill.save()
barb = Product(
name="Barbar",
code="BARB",
product_type=p,
purchase_price="1.50",
selling_price="1.7",
special_selling_price="1.6",
club=main_club,
)
barb.save()
cble = Product(
name="Chimay Bleue",
code="CBLE",
product_type=p,
purchase_price="1.50",
selling_price="1.7",
special_selling_price="1.6",
club=main_club,
)
cble.save()
cons = Product(
name="Consigne Eco-cup",
code="CONS",
product_type=verre,
purchase_price="1",
selling_price="1",
special_selling_price="1",
club=main_club,
)
cons.id = 1152
cons.save()
dcons = Product(
name="Déconsigne Eco-cup",
code="DECO",
product_type=verre,
purchase_price="-1",
selling_price="-1",
special_selling_price="-1",
club=main_club,
)
dcons.id = 1151
dcons.save()
Product(
name="Corsendonk",
code="CORS",
product_type=p,
purchase_price="1.50",
selling_price="1.7",
special_selling_price="1.6",
club=main_club,
).save()
Product(
name="Carolus",
code="CARO",
product_type=p,
purchase_price="1.50",
selling_price="1.7",
special_selling_price="1.6",
club=main_club,
).save()
mde = Counter.objects.filter(name="MDE").first()
mde.products.add(barb)
mde.products.add(cble)
mde.products.add(cons)
mde.products.add(dcons)
mde.sellers.add(skia)
mde.save()
eboutic = Counter.objects.filter(name="Eboutic").first()
eboutic.products.add(barb)
eboutic.products.add(cotis)
eboutic.products.add(cotis2)
eboutic.products.add(refill)
eboutic.save()
refound_counter = Counter(name="Carte AE",
club=refound,
type="OFFICE")
refound_counter.save()
refound_product = Product(
name="remboursement",
code="REMBOURS",
purchase_price="0",
selling_price="0",
special_selling_price="0",
club=refound,
)
refound_product.save()
# Accounting test values:
BankAccount(name="AE TG", club=main_club).save()
BankAccount(name="Carte AE", club=main_club).save()
ba = BankAccount(name="AE TI", club=main_club)
ba.save()
ca = ClubAccount(name="Troll Penché", bank_account=ba, club=troll)
ca.save()
gj = GeneralJournal(name="A16",
start_date=date.today(),
club_account=ca)
gj.save()
credit = AccountingType(code="74",
label="Subventions d'exploitation",
movement_type="CREDIT")
credit.save()
debit = AccountingType(
code="606",
label="Achats non stockés de matières et fournitures(*1)",
movement_type="DEBIT",
)
debit.save()
debit2 = AccountingType(
code="604",
label="Achats d'études et prestations de services(*2)",
movement_type="DEBIT",
)
debit2.save()
buying = AccountingType(code="60",
label="Achats (sauf 603)",
movement_type="DEBIT")
buying.save()
comptes = AccountingType(code="6",
label="Comptes de charge",
movement_type="DEBIT")
comptes.save()
simple = SimplifiedAccountingType(label="Je fais du simple 6",
accounting_type=comptes)
simple.save()
woenzco = Company(name="Woenzel & co")
woenzco.save()
operation_list = [
(
27,
"J'avais trop de bière",
"CASH",
None,
buying,
"USER",
skia.id,
"",
None,
),
(
4000,
"Ceci n'est pas une opération... en fait si mais non",
"CHECK",
None,
debit,
"COMPANY",
woenzco.id,
"",
23,
),
(
22,
"C'est de l'argent ?",
"CARD",
None,
credit,
"CLUB",
troll.id,
"",
None,
),
(
37,
"Je paye CASH",
"CASH",
None,
debit2,
"OTHER",
None,
"tous les étudiants <3",
None,
),
(300, "Paiement Guy", "CASH", None, buying, "USER", skia.id,
"", None),
(32.3, "Essence", "CASH", None, buying, "OTHER", None,
"station", None),
(
46.42,
"Allumette",
"CHECK",
None,
credit,
"CLUB",
main_club.id,
"",
57,
),
(
666.42,
"Subvention de far far away",
"CASH",
None,
comptes,
"CLUB",
main_club.id,
"",
None,
),
(
496,
"Ça, c'est un 6",
"CARD",
simple,
None,
"USER",
skia.id,
"",
None,
),
(
17,
"La Gargotte du Korrigan",
"CASH",
None,
debit2,
"CLUB",
bar_club.id,
"",
None,
),
]
for op in operation_list:
operation = Operation(
journal=gj,
date=date.today(),
amount=op[0],
remark=op[1],
mode=op[2],
done=True,
simpleaccounting_type=op[3],
accounting_type=op[4],
target_type=op[5],
target_id=op[6],
target_label=op[7],
cheque_number=op[8],
)
operation.clean()
operation.save()
# Adding user sli
sli = User(
username="******",
last_name="Li",
first_name="S",
email="*****@*****.**",
date_of_birth="1942-06-12",
)
sli.set_password("plop")
sli.save()
sli.view_groups = [
Group.objects.filter(
name=settings.SITH_MAIN_MEMBERS_GROUP).first().id
]
sli.save()
sli_profile_path = os.path.join(root_path,
"core/fixtures/images/5.jpg")
with open(sli_profile_path, "rb") as f:
name = str(sli.id) + "_profile.jpg"
sli_profile = SithFile(
parent=profiles_root,
name=name,
file=resize_image(Image.open(BytesIO(f.read())), 400,
"JPEG"),
owner=sli,
is_folder=False,
mime_type="image/jpeg",
size=os.path.getsize(sli_profile_path),
)
sli_profile.file.name = name
sli_profile.save()
sli.profile_pict = sli_profile
sli.save()
# Adding user Krophil
krophil = User(
username="******",
last_name="Phil'",
first_name="Kro",
email="*****@*****.**",
date_of_birth="1942-06-12",
)
krophil.set_password("plop")
krophil.save()
krophil_profile_path = os.path.join(root_path,
"core/fixtures/images/6.jpg")
with open(krophil_profile_path, "rb") as f:
name = str(krophil.id) + "_profile.jpg"
krophil_profile = SithFile(
parent=profiles_root,
name=name,
file=resize_image(Image.open(BytesIO(f.read())), 400,
"JPEG"),
owner=krophil,
is_folder=False,
mime_type="image/jpeg",
size=os.path.getsize(krophil_profile_path),
)
krophil_profile.file.name = name
krophil_profile.save()
krophil.profile_pict = krophil_profile
krophil.save()
# Adding user Com Unity
comunity = User(
username="******",
last_name="Unity",
first_name="Com",
email="*****@*****.**",
date_of_birth="1942-06-12",
)
comunity.set_password("plop")
comunity.save()
comunity.groups.set(
[Group.objects.filter(name="Communication admin").first().id])
comunity.save()
Membership(
user=comunity,
club=bar_club,
start_date=timezone.now(),
role=settings.SITH_CLUB_ROLES_ID["Board member"],
).save()
# Adding user tutu
tutu = User(
username="******",
last_name="Tu",
first_name="Tu",
email="*****@*****.**",
date_of_birth="1942-06-12",
)
tutu.set_password("plop")
tutu.save()
tutu.groups.set([settings.SITH_GROUP_PEDAGOGY_ADMIN_ID])
tutu.save()
# Adding subscription for sli
s = Subscription(
member=User.objects.filter(pk=sli.pk).first(),
subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[0],
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
StudentCard(uid="9A89B82018B0A0", customer=sli.customer).save()
# Adding subscription for Krophil
s = Subscription(
member=User.objects.filter(pk=krophil.pk).first(),
subscription_type=list(settings.SITH_SUBSCRIPTIONS.keys())[0],
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Com Unity
s = Subscription(
member=comunity,
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
# Tutu
s = Subscription(
member=tutu,
subscription_type=default_subscription,
payment_method=settings.SITH_SUBSCRIPTION_PAYMENT_METHOD[0][0],
)
s.subscription_start = s.compute_start()
s.subscription_end = s.compute_end(
duration=settings.SITH_SUBSCRIPTIONS[s.subscription_type]
["duration"],
start=s.subscription_start,
)
s.save()
Selling(
label=dcons.name,
product=dcons,
counter=mde,
unit_price=dcons.selling_price,
club=main_club,
quantity=settings.SITH_ECOCUP_LIMIT + 3,
seller=skia,
customer=krophil.customer,
).save()
# Add barman to counter
c = Counter.objects.get(id=2)
c.sellers.add(User.objects.get(pk=krophil.pk))
c.save()
# Create an election
public_group = Group.objects.get(id=settings.SITH_GROUP_PUBLIC_ID)
subscriber_group = Group.objects.get(
name=settings.SITH_MAIN_MEMBERS_GROUP)
ae_board_group = Group.objects.get(
name=settings.SITH_MAIN_BOARD_GROUP)
el = Election(
title="Élection 2017",
description="La roue tourne",
start_candidature="1942-06-12 10:28:45+01",
end_candidature="2042-06-12 10:28:45+01",
start_date="1942-06-12 10:28:45+01",
end_date="7942-06-12 10:28:45+01",
)
el.save()
el.view_groups.add(public_group)
el.edit_groups.add(ae_board_group)
el.candidature_groups.add(subscriber_group)
el.vote_groups.add(subscriber_group)
el.save()
liste = ElectionList(title="Candidature Libre", election=el)
liste.save()
listeT = ElectionList(title="Troll", election=el)
listeT.save()
pres = Role(election=el,
title="Président AE",
description="Roi de l'AE")
pres.save()
resp = Role(election=el,
title="Co Respo Info",
max_choice=2,
description="Ghetto++")
resp.save()
cand = Candidature(role=resp,
user=skia,
election_list=liste,
program="Refesons le site AE")
cand.save()
cand = Candidature(
role=resp,
user=sli,
election_list=liste,
program="Vasy je deviens mon propre adjoint",
)
cand.save()
cand = Candidature(role=resp,
user=krophil,
election_list=listeT,
program="Le Pôle Troll !")
cand.save()
cand = Candidature(
role=pres,
user=sli,
election_list=listeT,
program="En fait j'aime pas l'info, je voulais faire GMC",
)
cand.save()
# Forum
room = Forum(
name="Salon de discussions",
description="Pour causer de tout",
is_category=True,
)
room.save()
Forum(name="AE", description="Réservé au bureau AE",
parent=room).save()
Forum(name="BdF", description="Réservé au bureau BdF",
parent=room).save()
hall = Forum(
name="Hall de discussions",
description="Pour toutes les discussions",
parent=room,
)
hall.save()
various = Forum(name="Divers",
description="Pour causer de rien",
is_category=True)
various.save()
Forum(name="Promos",
description="Réservé aux Promos",
parent=various).save()
ForumTopic(forum=hall)
# News
friday = timezone.now()
while friday.weekday() != 4:
friday += timedelta(hours=6)
friday.replace(hour=20, minute=0, second=0)
# Event
n = News(
title="Apero barman",
summary="Viens boire un coup avec les barmans",
content="Glou glou glou glou glou glou glou",
type="EVENT",
club=bar_club,
author=subscriber,
is_moderated=True,
moderator=skia,
)
n.save()
NewsDate(
news=n,
start_date=timezone.now() + timedelta(hours=70),
end_date=timezone.now() + timedelta(hours=72),
).save()
n = News(
title="Repas barman",
summary="Enjoy la fin du semestre!",
content="Viens donc t'enjailler avec les autres barmans aux "
"frais du BdF! \o/",
type="EVENT",
club=bar_club,
author=subscriber,
is_moderated=True,
moderator=skia,
)
n.save()
NewsDate(
news=n,
start_date=timezone.now() + timedelta(hours=72),
end_date=timezone.now() + timedelta(hours=84),
).save()
n = News(
title="Repas fromager",
summary="Wien manger du l'bon fromeug'",
content="Fô viendre mangey d'la bonne fondue!",
type="EVENT",
club=bar_club,
author=subscriber,
is_moderated=True,
moderator=skia,
)
n.save()
NewsDate(
news=n,
start_date=timezone.now() + timedelta(hours=96),
end_date=timezone.now() + timedelta(hours=100),
).save()
n = News(
title="SdF",
summary="Enjoy la fin des finaux!",
content="Viens faire la fête avec tout plein de gens!",
type="EVENT",
club=bar_club,
author=subscriber,
is_moderated=True,
moderator=skia,
)
n.save()
NewsDate(
news=n,
start_date=friday + timedelta(hours=24 * 7 + 1),
end_date=timezone.now() + timedelta(hours=24 * 7 + 9),
).save()
# Weekly
n = News(
title="Jeux sans faim",
summary="Viens jouer!",
content="Rejoins la fine équipe du Troll Penché et viens "
"d'amuser le Vendredi soir!",
type="WEEKLY",
club=troll,
author=subscriber,
is_moderated=True,
moderator=skia,
)
n.save()
for i in range(10):
NewsDate(
news=n,
start_date=friday + timedelta(hours=24 * 7 * i),
end_date=friday + timedelta(hours=24 * 7 * i + 8),
).save()
# Create som data for pedagogy
UV(
code="PA00",
author=User.objects.get(id=0),
credit_type=settings.SITH_PEDAGOGY_UV_TYPE[3][0],
manager="Laurent HEYBERGER",
semester=settings.SITH_PEDAGOGY_UV_SEMESTER[3][0],
language=settings.SITH_PEDAGOGY_UV_LANGUAGE[0][0],
department=settings.SITH_PROFILE_DEPARTMENTS[-2][0],
credits=5,
title="Participation dans une association étudiante",
objectives=
"* Permettre aux étudiants de réaliser, pendant un semestre, un projet culturel ou associatif et de le valoriser.",
program=
"""* Semestre précédent proposition d'un projet et d'un cahier des charges
* Evaluation par un jury de six membres
* Si accord réalisation dans le cadre de l'UV
* Compte-rendu de l'expérience
* Présentation""",
skills=
"""* Gérer un projet associatif ou une action éducative en autonomie:
* en produisant un cahier des charges qui -définit clairement le contexte du projet personnel -pose les jalons de ce projet -estime de manière réaliste les moyens et objectifs du projet -définit exactement les livrables attendus
* en étant capable de respecter ce cahier des charges ou, le cas échéant, de réviser le cahier des charges de manière argumentée.
* Relater son expérience dans un rapport:
* qui permettra à d'autres étudiants de poursuivre les actions engagées
* qui montre la capacité à s'auto-évaluer et à adopter une distance critique sur son action.""",
key_concepts="""* Autonomie
* Responsabilité
* Cahier des charges
* Gestion de projet""",
hours_THE=121,
hours_TE=4,
).save()
]
return show(request,
request.POST.get("subkey", ""),
extra_context={"xmpp_form": form})
subscription.put()
return HttpResponseRedirect(subscription.get_absolute_url() + "#xmpp")
def incoming_xmpp(request):
try:
message = xmpp.Message(request.POST)
except Exception, e:
logging.warn("Failed to parse XMPP Message: %s" % e)
return HttpResponse()
sender = message.sender.split("/")[0]
subscription = Subscription.all().filter("xmpp =", sender).get()
if subscription is None:
message.reply(
"I don't know you. Please create a Seriesly subscription at http://www.seriesly.com"
)
logging.warn("Sender not found: %s" % sender)
return HttpResponse()
if not subscription.activated_xmpp and message.body == "OK":
subscription.activated_xmpp = True
subscription.put()
message.reply("Your Seriesly XMPP Subscription is now activated.")
elif not subscription.activated_xmpp:
message.reply(
"Someone requested this Seriesly Subscription to your XMPP address: %s . Please type 'OK' to confirm."
% subscription.get_domain_absolute_url())
else:
def create_initial_member(sender, instance, **kwargs):
a = Subscription(user=instance.author, community=instance)
a.save()
def feed_rss_public(request, public_id, template="rss_public.xml"):
subscription = Subscription.all().filter("public_id =", public_id).get()
if subscription is None:
raise Http404
return HttpResponse(_feed(request, subscription, template, public=True),
mimetype="application/rss+xml")
def calendar_public(request, public_id):
subscription = Subscription.all().filter("public_id =", public_id).get()
if subscription is None:
raise Http404
return _calendar(request, subscription, public=True)
def guide(request, subkey):
subscription = Subscription.all().filter("subkey =", subkey).get()
if subscription is None:
raise Http404
return _guide(request, subscription)
def subscribe(request):
form = SubscriptionForm(request.POST)
if not form.is_valid():
return index(request, form=form)
editing = False
if form.cleaned_data["subkey"] == "":
subkey = Subscription.generate_subkey()
subscription = Subscription(last_changed=datetime.datetime.now(),
subkey=subkey)
else:
editing = True
subkey = form.cleaned_data["subkey"]
subscription = form._subscription
sub_settings = {}
subscription.set_settings(sub_settings)
try:
selected_shows = Show.get_by_id(map(int, form.cleaned_data["shows"]))
except ValueError:
return index(request, form=form)
old_shows = []
if editing:
old_shows = subscription.get_shows()
subscription.reset_cache(selected_shows)
subscription.put() # stay here, need key for setting shows!
if editing:
subscription.set_shows(selected_shows, old_shows=old_shows)
else:
subscription.set_shows(selected_shows)
response = HttpResponseRedirect(subscription.get_absolute_url())
response.set_cookie("subkey", subkey, max_age=31536000)
return response
def hasActiveSubscription(ip, partyId, partnerId):
if partyId and partyId.isdigit() and len(Subscription.getActiveById(partyId, partnerId)) > 0:
return True
if ip and len(Subscription.getActiveByIp(ip, partnerId)) > 0:
return True
return False