def events(self, request):
event = Event()
serializer = EventSerializer(event.list_all_events_for_training(),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def create(self, request):
decoded_token = decode_token(request.META)
serializer = EventSerializer(data=request.data)
if serializer.is_valid():
event = Event()
data = serializer.data
data['calendar_id'] = -1
data['created'] = now()
data['updated'] = now()
data['user_id'] = decoded_token['user_id']
inserted = event.insert_event(data)
result = {}
if inserted.get('inserted', 0) == 1:
e = EventSerializer(event.get_event_with_pk(
inserted['generated_keys'][0]),
many=True)
if len(e.data) > 0:
result = e.data[0]
event.close()
return Response(result, status=status.HTTP_201_CREATED)
return Response(serializer.errors)
def test_event_creation(self):
user = User(
name='Johannes',
password='******',
last_login=timezone.now(),
email='*****@*****.**',
)
user.save()
agent = Agent(
name='CloudVM',
status=True,
env='01234567890123456789',
version='12345',
address='10.0.0.1',
)
agent.save()
event = Event(
level='none',
data='Some data test',
arquivado=False,
date=timezone.now(),
agent=agent,
user=user,
)
event.full_clean()
event.save()
ev = Event.objects.get(pk=event.pk)
self.assertEqual(event.level, ev.level)
self.assertEqual(event.agent.name, ev.agent.name)
self.assertEqual(event.user.name, ev.user.name)
def update_application(self, request, deserialized):
user = request.user
application = Application.objects.get(pk=deserialized['appId'])
try:
if deserialized['confirm']:
if application.owner_id == user.account_id:
application.is_confirmed_by_owner = 'YES'
else:
application.is_confirmed_by_tenant = 'YES'
if application.is_confirmed_by_tenant == application.is_confirmed_by_owner == 'YES':
application.status = 'CONFIRMED'
except:
pass
application.ejari_no = deserialized['leaseApplicationDetails'][
'contractNo']
application.start_date = deserialized['leaseApplicationDetails'][
'contractStartDate']
application.end_date = deserialized['leaseApplicationDetails'][
'contractEndDate']
application.address = deserialized['leaseApplicationDetails'][
'address']
application.premis_no = deserialized['leaseApplicationDetails'][
'premiseNo']
application.total_contract_value = deserialized[
'leaseApplicationDetails']['securityDepositAmount']
application.save()
registrationEvent = Event(
referenceid=application.id,
what="APPLICATION CONFIRMATION",
who=user.account_id,
)
registrationEvent.save()
def createTestEvent():
e = Event(
id="1234",
name="Test Event",
description=
"Test Description - isn't it long? No? Better? lorium ipsum?",
url="http://notarealevent.com/1234",
vanity_url="http://iamsupercool.com/1234",
start=datetime.strptime("2019-10-13 10:00:00",
"%Y-%m-%d %H:%M:%S").astimezone(pytz.utc),
end=datetime.strptime("2019-10-13 12:00:00",
"%Y-%m-%d %H:%M:%S").astimezone(pytz.utc),
org_id="1234",
date_created=datetime.now(pytz.utc),
date_modified=datetime.now(pytz.utc),
date_published=datetime.now(pytz.utc),
status="live",
currency="USD",
online_event=True,
hide_start_date=False,
hide_end_date=False,
max_price=10.32,
min_price=7.34,
)
return e
def destroy(self, request, pk=None):
decoded_token = decode_token(request.META)
event = Event()
deleted = event.delete_event_with_user_id(
pk, int(decoded_token['user_id']))
event.close()
return Response({"data": deleted}, status=status.HTTP_200_OK)
def __map_to_event_bo(self, suggestion_id):
event_bo = Event()
event_bo.created = datetime.now()
event_bo.modified = datetime.now()
event_bo.event_type = EventTypes.ACTION
event_bo.sub_type = EventActionSubTypes.SYSTEM
event_bo.text = f"Lisätty tunnisteet: "
event_bo.suggestion_id = suggestion_id
return event_bo
def list(self, request, calendar_id):
decoded_token = decode_token(request.META)
event = Event()
serializer = EventSerializer(event.list_events(
decoded_token['user_id'], calendar_id),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def new_event(user_id, title, description, timestamp_begin, timestamp_end):
_event = Event(user_id=user_id,
title=title,
description=description,
timestamp_begin=timestamp_begin,
timestamp_end=timestamp_end)
db.session.add(_event)
db.session.commit()
return _event
def create(fields: dict) -> Event:
event_categories_ids = fields.get("event_categories_ids", [])
fields.pop('event_categories_ids', None)
event_categories = eventCategoryService.getAllIds(event_categories_ids)
if event_categories:
fields["event_categories"] = event_categories
new_event = Event(**fields)
db.session.add(new_event)
db.session.commit()
return new_event
def create_event(type, owners, object_id):
"""
Создаёт событие
"""
event = Event()
event.type = type
event.object_id = object_id
event.save()
for owner in owners:
event.owners.add(owner)
event.save()
return event
def events(self, request, client_id, user_id):
if not self.is_valid(client_id, user_id):
return Response({"message": "Not found."},
status=status.HTTP_404_NOT_FOUND)
event = Event()
serializer = EventSerializer(event.list_all_events_for_training_user(
int(user_id)),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def update(self, request, client_id, user_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
event = Event()
# TODO revisarlo con el serializer
data = request.data.copy()
data['updated'] = now()
updated = event.update_event_with_pk(pk, data)
event.close()
return Response({"data": updated}, status=status.HTTP_200_OK)
def free_busy(self, request, calendar_id):
decoded_token = decode_token(request.META)
from_date = request.data('from_date', now() - timedelta(days=14))
to_date = request.data('to_date', now() + timedelta(days=14))
event = Event()
serializer = EventSerializer(event.free_busy(decoded_token['user_id'],
from_date, to_date),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def create_event(event_creator, category, active=True, id=5):
event = Event(id=id,
title="test title default",
description="test description default",
venue="test venue",
start_date=date,
end_date=date,
creator=event_creator,
social_event=category,
active=active,
created_at=date)
event.save()
return event
def __map_comments_to_comments_bo(self, comments, suggestion_id):
comments_bo = []
if comments is not None and len(comments) > 0:
for comment in comments:
comment_bo = Event()
comment_bo.created = comment.created
comment_bo.modified = comment.modified
comment_bo.event_type = EventTypes.COMMENT
comment_bo.text = comment.text
comment_bo.suggestion_id = suggestion_id
if comment_bo.user_id is None:
comment_bo.user_id = 1
comments_bo.append(comment_bo)
return comments_bo
def retrieve(self, request, calendar_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
event = Event()
serializer = EventSerializer(event.get_event(decoded_token['user_id'],
calendar_id, pk),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def update_event(event_id, user_id, title, description, timestamp_begin, timestamp_end):
_event = Event(user_id=user_id,
title=title,
description=description,
timestamp_begin=timestamp_begin,
timestamp_end=timestamp_end)
db.session.filter_by(_id=event_id).update({'user_id': user_id,
'title': title,
'description': description,
'timestamp_begin': timestamp_begin,
'timestamp_end': timestamp_end
})
db.session.commit()
return _event
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('startDate', default='', help='Start date')
parser.add_argument('title', default='Where is my title', help='Title')
args = parser.parse_args()
print(args)
event = Event()
event.title = args.title
event.startDate = parse(args.startDate)
event.endDate = parse(args.startDate)
db.session.add(event)
db.session.commit()
all_events = Event.query.all()
event_schema = EventSchema(many=True)
return event_schema.jsonify(all_events)
def retrieve(self, request, client_id, user_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
# TODO Add a different endpoint without using user_id
if not self.is_valid(client_id,
user_id) or not user_id == "554-586-725":
return Response({"message": "Not found."},
status=status.HTTP_404_NOT_FOUND)
event = Event()
serializer = EventSerializer(event.get_event_with_pk(pk), many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def free_busy(self, request, client_id, user_id):
if not self.is_valid(client_id, user_id):
return Response({"message": "Not found."},
status=status.HTTP_404_NOT_FOUND)
from_date = request.data.get('from_date',
(now() - timedelta(days=14)).isoformat())
to_date = request.data.get('to_date',
(now() + timedelta(days=14)).isoformat())
event = Event()
serializer = EventSerializer(event.free_busy(int(user_id), from_date,
to_date),
many=True)
event.close()
return Response(serializer.data, status=status.HTTP_200_OK)
def teams_on_call(team_id):
"""
POST:
{"start":"2014-12-23", "username":"******"}
Default to the current day if nothing specified
"""
if request.method == 'GET':
req_start = request.args.get('start', None, type=float)
req_end = request.args.get('end', None, type=float)
date_start = (date.fromtimestamp(req_start) if req_start is not None else date.today())
date_end = (date.fromtimestamp(req_end) if req_end is not None else date.today())
events = _get_events_for_dates(team_id,
date_start,
date_end,
predict=True)
event_array = [e.to_json() if isinstance(e, Event) else e for e in events]
# For FullCalendar so it returns in the correct way
if request.args.get('minimal'):
return Response(json.dumps(event_array),
mimetype='application/json')
return jsonify({'range':[str(date_start), str(date_end)],
'on_call': event_array})
if request.method == 'POST':
if _can_add_event(team_id, request.json.get('start'), request.json.get('end')):
events = _get_events_for_dates(team_id,
request.json.get('start'),
request.json.get('end'))
newe = Event(request.json.get('username'),
team_id,
current_app.config['ROLES'][0] if events == [] else _other_role(events[0].role),
_str_to_date(request.json.get('start')))
db.session.add(newe)
else:
# flash('Cannot add event, maximum for day has been reached', 'danger')
return _api_error('Cannot add event, maximum for day has been reached', 'danger')
# TODO: Return status and result of action
db.session.commit()
return Response(status=200)
def available(self, request, calendar_id):
decoded_token = decode_token(request.META)
from_date = request.data.get('from_date', None)
to_date = request.data.get('to_date', None)
if from_date is None or to_date is None:
return Response(
{
'message':
'Invalid information provided, please include values for from_date and to_date.'
},
status=status.HTTP_400_BAD_REQUEST)
event = Event()
result = event.available(decoded_token['user_id'], from_date, to_date)
event.close()
return Response({"available": result}, status=status.HTTP_200_OK)
def add_post_to_db(posts):
category_q = Category.objects.values('name')
categories = []
for item in category_q:
categories.append(item['name'])
for post in posts:
if post["name"] and post["image"] and post["category"] \
and post["date"] and post["address"] \
and post["price"] and post["description"] and post["link"]:
e = Event()
e.name = post["name"],
e.image = post["image"],
e.category = Category.objects.get(id=1),
e.date = post["date"],
e.address = post["address"],
e.price = post["price"],
e.description = post["description"],
e.link = post["link"]
e.save()
print(e)
def destroy(self, request, calendar_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
calendar = Calendar()
obj = calendar.get(decoded_token['user_id'], calendar_id)
calendar.close()
if len(obj) < 1:
return Response({"message": "calendar_id does not exists."},
status=status.HTTP_404_NOT_FOUND)
event = Event()
deleted = event.delete_event(calendar_id, pk)
event.close()
return Response({"data": deleted}, status=status.HTTP_200_OK)
def save_events(events):
for e in events:
# deal with some events not having a published date
if 'published' in e:
published = pytz.utc.localize(datetime.strptime(e['published'],'%Y-%m-%dT%H:%M:%SZ'))
else:
published = None
#why have a paid event that doesn't have a price??
min_price = 0.0
max_price = 0.0
if 'ticket_availability' in e and e['ticket_availability'] is not None:
if 'minimum_ticket_price' in e['ticket_availability'] and e['ticket_availability']['minimum_ticket_price'] is not None:
if 'major_value' in e['ticket_availability']['minimum_ticket_price']:
min_price = e['ticket_availability']['minimum_ticket_price']['major_value']
if 'maximum_ticket_price' in e['ticket_availability'] and e['ticket_availability']['maximum_ticket_price'] is not None:
if 'major_value' in e['ticket_availability']['maximum_ticket_price']:
max_price = e['ticket_availability']['maximum_ticket_price']['major_value']
event = Event(
id = e['id'],
name = e['name']['text'],
description = e['description']['text'],
url = e['url'],
start = datetime.strptime(e['start']['utc'],'%Y-%m-%dT%H:%M:%SZ').astimezone(gettz(e['start']['timezone'])),
end = datetime.strptime(e['end']['utc'],'%Y-%m-%dT%H:%M:%SZ').astimezone(gettz(e['end']['timezone'])),
org_id = e['organization_id'],
date_created = pytz.utc.localize(datetime.strptime(e['created'],'%Y-%m-%dT%H:%M:%SZ')),
date_modified = pytz.utc.localize(datetime.strptime(e['changed'],'%Y-%m-%dT%H:%M:%SZ')),
date_published = published,
status = e['status'],
currency = e['currency'],
online_event = e['online_event'],
hide_start_date = e['hide_start_date'],
hide_end_date = e['hide_end_date'],
min_price = min_price,
max_price = max_price,
)
with transaction.atomic():
event.save()
def handle_event_proxy(event, chain):
event_key = get_event_key(event)
existed_event = Event.query.filter(Event.key == event_key).first()
if existed_event:
return
serialized_event = dict(
event.__dict__,
**{
'args': event['args'].__dict__,
'transactionHash': event['transactionHash'].hex(),
'blockHash': event['blockHash'].hex(),
},
)
# TODO: event handler
print(chain, event['event'])
new_event = Event(key=event_key,
chain=chain,
type=event['event'],
content=json.dumps(serialized_event))
new_event.save()
def api_create_event_view(request):
# Get user's IP
request_data = request.META.get('HTTP_X_FORWARDED_FOR')
if request_data:
user_ip = request_data.split(',')[0]
else:
user_ip = request.META.get('REMOTE_ADDR')
print(f'> POST request from { user_ip }')
user_env = request.data['env']
user_version = request.data['version']
try:
env = Environment.objects.get(name=user_env)
except Environment.DoesNotExist:
return Response(status=status.HTTP_412_PRECONDITION_FAILED)
try:
agent = Agent.objects.get(address=user_ip,
version=user_version,
env=env.pk)
except Agent.DoesNotExist:
agent = Agent.objects.create(address=user_ip,
version=user_version,
env=env)
user = CustomUser.objects.get(pk=4)
event = Event(user=user, agent=agent)
if request.method == "POST":
serializer = EventSerializer(event, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_401_BAD_REQUEST)
def update(self, request, calendar_id, pk=None):
if pk is None:
return Response({'message': 'Provide the object id.'},
status=status.HTTP_400_BAD_REQUEST)
decoded_token = decode_token(request.META)
calendar = Calendar()
obj = calendar.get(decoded_token['user_id'], calendar_id)
calendar.close()
if len(obj) < 1:
return Response({"message": "calendar_id does not exists."},
status=status.HTTP_404_NOT_FOUND)
event = Event()
# TODO Revisarlo con el serializer
data = request.data
data['updated'] = now()
updated = event.update_event(calendar_id, pk, data)
event.close()
return Response({"data": updated}, status=status.HTTP_200_OK)
def qavailable(self, request, client_id, user_id):
if not self.is_valid(client_id, user_id):
return Response({"message": "Not found."},
status=status.HTTP_404_NOT_FOUND)
from_date = request.data.get('from_date',
(now() - timedelta(hours=3)).isoformat())
to_date = request.data.get('to_date',
(now() - timedelta(hours=3)).isoformat())
if from_date is None or to_date is None:
return Response(
{
'message':
'Invalid information provided, please include values for from_date and to_date.'
},
status=status.HTTP_400_BAD_REQUEST)
event = Event()
result = event.available(int(user_id), from_date, to_date)
event.close()
return Response({"available": result}, status=status.HTTP_200_OK)
