def setUp(self):
user = UserModel.objects.create_user(name="test test",
password="******",
email="*****@*****.**")
self.client = APIClient()
self.client.force_authenticate(user=user)
future_date_1 = datetime.now() + timedelta(days=+30)
future_date_2 = datetime.now() + timedelta(days=+37)
past_date_1 = datetime.now() + timedelta(days=+37)
self.events = Event.objects.bulk_create([
Event(
name="Powerwolf in Wroclaw",
event_date=future_date_1,
place="Wroclaw",
description="lorem ipsum",
),
Event(
name="Powerwolf in Wroclaw",
event_date=future_date_2,
place="Wroclaw",
description="lorem ipsum",
),
Event(
name="Powerwolf in Wroclaw",
event_date=past_date_1,
place="Wroclaw",
description="lorem ipsum",
),
])
def setUp(self):
self.factory = RequestFactory(HTTP_HOST='test.com')
now = timezone.now()
test_fair = Fair(name="Armada 2000", current=True)
test_fair.save()
self.event = Event(fair=test_fair,
name='test',
event_start=now,
event_end=now,
registration_start=now,
registration_end=now,
registration_last_day_cancel=now,
public_registration=True,
published=True)
self.event.save()
self.hidden_event = Event(fair=test_fair,
name='hidden event',
event_start=now,
event_end=now,
registration_start=now,
registration_end=now,
registration_last_day_cancel=now,
public_registration=False)
self.hidden_event.save()
self.request = self.factory.get('/api/events/')
def setUp(self):
weekly = Rule(frequency="WEEKLY")
weekly.save()
daily = Rule(frequency="DAILY")
daily.save()
cal = Calendar(name="MyCal")
cal.save()
self.event1 = Event(
**{
'title': 'Weekly Event',
'start': datetime.datetime(2009, 4, 1, 8, 0),
'end': datetime.datetime(2009, 4, 1, 9, 0),
'end_recurring_period': datetime.datetime(2009, 10, 5, 0, 0),
'rule': weekly,
'calendar': cal
})
self.event1.save()
self.event2 = Event(
**{
'title': 'Recent Event',
'start': datetime.datetime(2008, 1, 5, 9, 0),
'end': datetime.datetime(2008, 1, 5, 10, 0),
'end_recurring_period': datetime.datetime(2009, 5, 5, 0, 0),
'rule': daily,
'calendar': cal
})
self.event2.save()
def save(self, *args, **kwargs):
if (self.transmissionid == None):
var = str(uuid.uuid4())
self.transmissionid = var[26:36]
#Log events
event = Event()
event.EventTypeCode = "TRA"
event.EventSubjectId = self.transmissionid
event.EventSubjectName = self.SenderName
event.EventTypeReason = "Transmission added"
event.source = "Web App"
event.creator=self.creator
event.save()
if (self.bulk_upload_indicator == "Y" and self.backend_SOR_connection != "Disconnected"):
self.bulk_upload_indicator=""
self.response='Success'
super().save(*args, **kwargs)
#connect to backend
if self.backend_SOR_connection != "Disconnected":
#converty model object to json
serializer = TransmissionSerializer(self)
json_data = serializer.data
api = ApiDomains()
url=api.transmission
#url='https://94q78vev60.execute-api.us-east-1.amazonaws.com/Prod/intellidatatransmissionAPI'
#post data to the API for backend connection
resp = requests.post(url, json=json_data)
print("status code " + str(resp.status_code))
if resp.status_code == 502:
resp.status_code = 201
obj = get_object_or_404(APICodes, http_response_code = resp.status_code)
status_message=obj.http_response_message
self.response=str(resp.status_code) + " - " + status_message
if resp.status_code == 201:
self.commit_indicator="Committed"
else:
self.commit_indicator="Not Committed"
#Log events
event = Event()
event.EventTypeCode = "TRC"
event.EventSubjectId = self.transmissionid
event.EventSubjectName = self.SenderName
event.EventTypeReason = "Transmission added to ODS"
event.source = "Web App"
event.creator=self.creator
event.save()
super().save(*args, **kwargs)
else:
print("not connected to backend!")
def eventView(request):
events = Event.objects.all()
try:
event_id = request.GET['id']
Event.objects.filter(id=event_id).delete()
except MultiValueDictKeyError:
pass
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
name = request.POST['name']
venue = request.POST['venue']
date = request.POST['date']
time = request.POST['time']
new_event = Event(name=name,
venue=venue,
date=date,
time=time)
new_event.save()
else:
form = EventForm()
context = {
'events': events,
'form': form,
}
return render(request, 'users/events.html', context)
def create_reminder(by, date, reminder_choice, registration, step, timezone):
offset = get_reminder_minutes_offset(reminder_choice)
when = date - dt.timedelta(minutes=offset)
reminder, created_at = Reminder.objects.get_or_create(
registration=registration)
reminder.step = step
reminder.by = by
reminder.when = when
reminder.date = date
reminder.timezone = timezone
reminder.save()
costumer_name = registration.costumer.get_full_name()
event = Event.objects.filter(reminder=reminder).first()
if not event:
event = Event(reminder=reminder)
event.user = registration.consultant
event.title = u'Ad Astra Reminder - {}'.format(costumer_name)
event.description = u'You have one {} with {}'.format(
reminder.get_step_display(), costumer_name)
event.start = date
event.end = date + dt.timedelta(minutes=30)
event.save()
def newstore(request):
context = {}
if request.method == "POST":
store_name = request.POST['store_name']
desc = request.POST['description']
date = request.POST['date']
time = request.POST['time']
poster = request.FILES['poster']
location = request.POST['location']
event = Event(shop=request.user,
Event_name=store_name,
Event_description=desc,
date=date,
time=time,
Event_poster=poster,
location=location)
event.save()
tickets = request.POST.getlist('ticket')
for ticket in tickets:
data = ticket.split(',')
Ticket.objects.create(event=event,
name=data[0],
quantity=data[1],
price=data[2])
context = {'success': True}
return render(request, 'dashboard/newstore.html', context)
def get_repeated_events(events, start_date_range, end_date_range):
items = []
for event in events:
start_date_generator = repeating_date_generator(
event.start_date, event.repetition)
end_date_generator = repeating_date_generator(event.end_date,
event.repetition)
start_date = event.start_date
end_date = event.end_date
event_ends = end_date_range if event.ends is None else min(
event.ends, end_date_range)
while event_ends > start_date:
if start_date_range <= start_date <= end_date_range:
rep_event = Event(title=event.title,
start_date=start_date,
end_date=end_date,
start_time=event.start_time,
end_time=event.end_time,
location=event.location,
description=event.description,
is_repeat=event.is_repeat,
repetition=event.repetition,
ends=event.ends,
id=event.id)
items.append(rep_event)
start_date = next(start_date_generator)
end_date = next(end_date_generator)
return items
def trigger_event(group_name, event_name):
event_source = Group.objects.get(name=group_name)
event_definition = EventDefinition.objects.get(name=event_name)
event_write = Event(event_definition=event_definition,
device_group=event_source)
event_write.save()
# completion of automation writes an event which could trigger another automation
automations = Automation.objects.filter(cause=event_definition,
source_group=event_source)
for automation in automations:
dummy_result = [None]
event_target = automation.target_group
config_id = str(event_target.get_config_id())
# initialize automation chain with triggered automation
automation_chain = signature(automation.effect,
args=dummy_result,
kwargs={'config_id': config_id})
a = automation
while a.next:
a = a.next
automation_chain |= (signature(
'events.tasks.evaluate_event',
kwargs={
'group_name': group_name,
'event_name': event_name
}) | signature(a.effect, kwargs={'config_id': config_id}))
automation_chain.apply_async()
def create_event(self):
"""
Create an event
"""
groups = MemberGroup.objects.all()
if len(groups) == 0:
self.stdout.write("Your database does not contain any "
"member groups.")
self.stdout.write("Creating a committee.")
self.create_member_group(Committee)
groups = MemberGroup.objects.all()
event = Event()
event.title_nl = _generate_title()
event.title_en = event.title_nl
event.description_nl = _faker.paragraph()
event.description_en = _faker.paragraph()
event.start = _faker.date_time_between("-30d", "+120d", _current_tz)
duration = math.ceil(random.expovariate(0.2))
event.end = event.start + timedelta(hours=duration)
event.organiser = random.choice(groups)
event.category = random.choice(Event.EVENT_CATEGORIES)[0]
if random.random() < 0.5:
week = timedelta(days=7)
event.registration_start = _faker.date_time_between_dates(
datetime_start=event.start - 4 * week,
datetime_end=event.start - week,
tzinfo=_current_tz,
)
event.registration_end = _faker.date_time_between_dates(
datetime_start=event.registration_start,
datetime_end=event.start,
tzinfo=_current_tz,
)
event.cancel_deadline = _faker.date_time_between_dates(
datetime_start=event.registration_end,
datetime_end=event.start,
tzinfo=_current_tz,
)
event.location_nl = _faker.street_address()
event.location_en = event.location_nl
event.map_location = event.location_nl
event.send_cancel_email = False
if random.random() < 0.5:
event.price = random.randint(100, 2500) / 100
event.fine = max(
5.0,
random.randint(round(100 * event.price),
round(500 * event.price)) / 100,
)
if random.random() < 0.5:
event.max_participants = random.randint(20, 200)
event.published = random.random() < 0.9
event.save()
def create_event(request):
if request.method == 'POST':
form = EventCreateForm(request.POST, target_user=request.user)
if form.is_valid():
title = form.cleaned_data['name']
description = form.cleaned_data['description']
event = Event(name=title,
description=description,
created_by=request.user)
event.save()
membership = EventMembership(user=request.user,
event=event,
is_organizer=True,
is_creator=True)
membership.save()
messages.success(
request,
f"Event successfully created! Click your event Event Settings button in the "
f"organizer toolbar to add more members.")
return redirect('general-home')
else:
context = {
'form': EventCreateForm(target_user=request.user),
'title': 'New Event'
}
return render(request, 'events/create_event.html', context=context)
def form_valid(self, form):
# set the submitter to be the current user
form.instance.user = self.request.user
# save the posted message
self.object = form.save()
# add event to the Event table
# build a JSON fragment out of the new song info
event_info = {
"user": self.object.user.username,
"time": TimeFilter(self.object.time),
"text": self.object.text,
}
if self.object.user.is_superuser:
event_info['user_class'] = "superuser"
elif self.object.user.is_staff:
event_info['user_class'] = "staff"
elif self.object.user.is_active:
event_info['user_class'] = "default"
else:
event_info['user_class'] = "none"
event = Event(audience_type=Event.AUTHENTICATED, event_type="CHAT", event_value=json.dumps(event_info))
event.save()
# return 204 NO CONTENT (prevents redirect)
return HttpResponse(status=204)
def parse(self, response):
for event in response.css(".seite-c-single"):
title = event.css(".article-title::text").extract_first()
category = event.css(".article-category::text").extract_first()
desc = event.css(".article-text::text").extract_first()
href = self.BASE_URL + event.css(".seite-c-single ::attr(href)").extract_first()
try:
start = [x.strip() for x in event.css(".date-display-start ::attr(content)").extract_first().split('T')][0]
start = datetime.datetime.strptime(start, '%Y-%m-%d').strftime('%Y-%m-%d')# %I:%m:%s.%f')
end = [x.strip() for x in event.css(".date-display-end ::attr(content)").extract_first().split('T')][0]
end = datetime.datetime.strptime(end, '%Y-%m-%d').strftime('%Y-%m-%d')# %I:%m:%s.%f')#2018-10-21 12:04:26.255181 2018-12-02 12:12:1543708800.000000
except:
start = [x.strip() for x in event.css(".date-display-single ::attr(content)").extract_first().split('T')][0]
start = datetime.datetime.strptime(start, '%Y-%m-%d').strftime('%Y-%m-%d')# %I:%m:%s.%f')
end = start
event_object = Event(title=title, start_date=start,
end_date=end,category=category,
link=href,description=desc,
web_source="Co-Berlin")
serializer = EventSerializer(event_object)
content = JSONRenderer().render(serializer.data)
stream = io.BytesIO(content)
data = JSONParser().parse(stream)
serializer = EventSerializer(data=data)
#print(serializer)
#print(serializer.is_valid())
serializer.is_valid()
try:
serializer.save()
except IntegrityError as e:
logger.error(e.__str__())
def create_event(self,
number,
series=None,
location=None,
start_date=None,
end_date=None,
is_published=True):
"""Create event object.
Args:
number: Identifier of the event (int).
location: Location of the event (Location).
start_date: Date of the event start (Date).
end_date: Date of the event end (Date).
is_published: Boolean if event is public (bool).
Returns:
Event object.
"""
if start_date is None:
start_date = date.today()
if end_date is None:
end_date = date.today()
event = Event(
name="Event {}".format(number),
series=series,
description="Description for Event {}".format(number),
start_date=start_date,
end_date=end_date,
location=location,
is_published=is_published,
)
event.save()
return event
def create_tech_event(request):
user = request.user
if user.role_set.filter(id=1):
if request.method == 'POST':
form = EventForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
description = form.cleaned_data['description']
event_type = 1
user_id = request.user.id
date = form.cleaned_data['date']
event = Event(user=request.user,
name=name,
description=description,
type=event_type,
date=date)
event.save()
return redirect('http://127.0.0.1:8000/custom_auth/profile/')
else:
return render(request, 'new_event.html', {'form': form})
else:
form = EventForm()
return render(request, "new_event.html", {'form': form})
else:
return render(request, 'not_permitted.html')
def test_event_get_occurrences_after(self):
recurring_event = Event(**self.recurring_data)
recurring_event.save()
occurrences = recurring_event.get_occurrences(start=datetime.datetime(2008, 1, 5),
end=datetime.datetime(2008, 1, 6))
occurrence = occurrences[0]
occurrence2 = recurring_event.occurrences_after(datetime.datetime(2008, 1, 5)).next()
self.assertEqual(occurrence, occurrence2)
def add_event(code):
#ToDo: make sure event isn't already in db
new_event = Event(api_url=api_url,
event_start=start_time,
title=api_object['name']['html'],
event_url=api_object['url'],
event_code=code)
new_event.save()
def test_get_occurrence(self):
event = Event(**self.recurring_data)
event.save()
occurrence = event.get_occurrence(datetime.datetime(2008, 1, 5, 8, 0))
self.assertEqual(occurrence.start, datetime.datetime(2008, 1, 5, 8))
occurrence.save()
occurrence = event.get_occurrence(datetime.datetime(2008, 1, 5, 8, 0))
self.assertTrue(occurrence.pk is not None)
def test_event_retrieve_category_person_time(self):
test_event = Event(title='@i created this #test')
test_event.save()
self.assertEqual(test_event.person, 'i')
self.assertEqual(test_event.category, 'test')
self.assertEqual(test_event.time.year, datetime.datetime.now().year)
self.assertEqual(test_event.time.month, datetime.datetime.now().month)
self.assertEqual(test_event.time.day, datetime.datetime.now().day)
def select_question(report, question, delta):
content = '{"question_id":%d}' % question.id
start = datetime.strptime(report.start, settings.DATE_INPUT_FORMATS[0])
timestamp = start + timedelta(seconds=delta)
event = Event(timestamp=timestamp,
interview=report,
type=Event.QUESTION_SELECTED,
content=content)
event.save()
def create_event(event, course_id):
NewEvent = Event()
course = Course.objects.get(course_id=course_id)
NewEvent.course_id = course
for k, v in test_events[event].items():
setattr(NewEvent, k, v)
NewEvent.save()
serializer = EventSerializer(NewEvent)
return JsonResponse(serializer.data, safe=False)
def ListEventsHistory(request, pk):
context = {}
prod_obj = get_object_or_404(Event, pk=pk)
api = ApiDomains()
url = api.event + "/" + "history"
#url = 'https://94q78vev60.execute-api.us-east-1.amazonaws.com/Prod/intellidataeventAPI/history'
payload = {'ident': prod_obj.eventid}
resp = requests.get(url, params=payload)
print(resp.status_code)
obj = get_object_or_404(APICodes, http_response_code=resp.status_code)
status_message = obj.http_response_message
mesg = str(resp.status_code) + " - " + status_message
if resp.status_code != 200:
# This means something went wrong.
#raise ApiError('GET /tasks/ {}'.format(resp.status_code))
#raise APIError(resp.status_code)
message = {'messages': mesg}
return render(request, "messages.html", context=message)
else:
json_data = []
dict_data = []
obj_data = []
json_data = resp.json()
#print(json_data[0])
#print(json_data[1])
for ix in range(len(json_data)):
obj = Event()
#dict_data.append(json.loads(json_data[ix]))
obj.pk = int(json_data[ix]["LOCAL_ID"])
obj.eventid = json_data[ix]["EVENT_ID"]
obj.EventTypeCode = json_data[ix]["EVENT_TYPE_CODE"]
obj.EventSubjectId = json_data[ix]["EVENT_SUBJECT_ID"]
obj.EventSubjectName = json_data[ix]["EVENT_SUBJECT_NAME"]
obj.EventTypeReason = json_data[ix]["EVENT_TYPE_REASON"]
obj.creator = User.objects.get(pk=int(json_data[ix]["CREATOR"]))
#obj.crerator = get_object_or_404(User, pk=obj.creatorid)
obj.EventDate = json_data[ix]["EVENT_DATE"]
obj.TransactionDate = json_data[ix]["TRANSACTION_DATE"]
obj.backend_SOR_connection = json_data[ix]["CONNECTION"]
obj.response = json_data[ix]["RESPONSE"]
obj.commit_indicator = json_data[ix]["COMMIT_INDICATOR"]
obj.record_status = json_data[ix]["RECORD_STATUS"]
obj_data.append(obj)
context = {'object_list': obj_data}
return render(request, "events/event_list.html", context=context)
def watchable_postsave(instance, created=False, *args, **kwargs):
if (not isinstance(instance, WatchableModel)) or not (isinstance(
instance, ModelWithAuthor)) or not created:
return
event = Event()
event.title = instance.get_title_for_event(instance)
event.author = instance.author
event.object = instance
event.content_type = ContentType.objects.get_for_model(instance)
event.save()
def migrate_events():
"""
Event Types
"""
"""
Events
"""
l_events = EventsEvent.objects.all()
user = User.objects.get(pk=1)
for l_event in l_events:
kwargs = {
'city': l_event.city,
'content': l_event.content,
'country': l_event.country,
'created': l_event.created,
'created_by': user,
'email': l_event.email,
'end_date': l_event.end_date,
'event_type': l_event.event_type,
'fax': l_event.fax,
'is_published': l_event.is_published,
'mobile': l_event.mobile,
'phone': l_event.phone,
'post_code': l_event.post_code,
'published': l_event.published,
'slug': l_event.slug,
'start_date': l_event.start_date,
'state': l_event.state,
'street': l_event.street,
'suburb': l_event.suburb,
'summary': l_event.summary,
'title': l_event.title,
'venue': l_event.venue,
'website': l_event.website,
'website_name': l_event.website_name,
}
event = Event(**kwargs)
try:
event.full_clean()
except ValidationError, e:
# Do something based on the errors contained in e.message_dict.
# Display them to a user, or handle them programatically.
print e
else:
print event
async def create_models(app: Application):
app['models'].update({
'message': Message(app.db),
'company': Company(app.db),
'unread': UnreadMessage(app.db),
'invite': Invite(app.db),
'event': Event(app.db),
'photo': Photo(app.db),
'user': User(app.db, {}),
'notif': Notification(app.db)
})
def rate_updated(rate, report, question, delta):
content = '{"new_rating":%d,"old_rating":%d, "question_id":%d}' \
% (random.randint(1, 9), rate, question.id)
start = datetime.strptime(report.start, settings.DATE_INPUT_FORMATS[0])
timestamp = start + timedelta(seconds=delta)
event = Event(timestamp=timestamp,
interview=report,
type=Event.RATE_UPDATED,
content=content)
event.save()
return event
def setUp(self):
self.event = Event(Event_name="Coffeebreak",
creator="Christoph",
description="This is my Coffeebreak",
latitude=100.45,
longitude=150.45,
address="New York, Manhattan",
date=datetime.datetime(2008, 11, 22, 19, 53, 42),
duration=datetime.timedelta(00, 02, 00, 00),
tags="Coffee",
image="ME")
def create(self, validated_data):
instance = Event() # .objects.create(**validated_data)
for field in validated_data:
if field != 'creator':
instance.__setattr__(field, validated_data[field])
user = self.context['request'].user
instance.creator = user
instance.save()
return instance
def rate_created(report, question, delta):
rate = random.randint(1, 9)
content = '{"rating":%d, "question_id":%d}' % (rate, question.id)
start = datetime.strptime(report.start, settings.DATE_INPUT_FORMATS[0])
timestamp = start + timedelta(seconds=delta)
event = Event(timestamp=timestamp,
interview=report,
type=Event.RATE_CREATED,
content=content)
event.save()
return rate
def setUp(self):
self.event = Event(Event_name="Coffeebreak",
creator="Christoph",
description="This is my Coffeebreak",
latitude=100.45,
longitude=150.45,
address="New York, Manhattan",
date="2015-11-10T13:04:48.356000Z",
duration="02:00:00",
tags="Coffee",
image="ME")
