def setUp(self):
self.unrelated_person = Person.objects.create_person(
email="*****@*****.**",
create_role=True,
)
self.organizer = Person.objects.create_person(
email="*****@*****.**",
create_role=True,
)
start_time = timezone.now() + timezone.timedelta(days=3)
end_time = timezone.now() + timezone.timedelta(days=3, hours=4)
self.a_subtype = EventSubtype.objects.create(
visibility=EventSubtype.VISIBILITY_ALL, label="A subtype")
self.another_subtype = EventSubtype.objects.create(
visibility=EventSubtype.VISIBILITY_ALL, label="Another subtype")
self.event = Event.objects.create(
name="Event",
start_time=start_time,
end_time=end_time,
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.a_subtype,
organizer_person=self.organizer,
)
self.past_event = Event.objects.create(
name="Event",
start_time=timezone.now() - timezone.timedelta(days=3),
end_time=timezone.now() - timezone.timedelta(days=2),
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.a_subtype,
organizer_person=self.organizer,
)
def setUp(self):
self.unrelated_person = Person.objects.create(
email="*****@*****.**",
create_role=True,
)
self.organizer = Person.objects.create(
email="*****@*****.**",
create_role=True,
)
self.report_person_form = PersonForm.objects.create(title="Form",
description="Form",
slug="formulaire")
self.subtype_with_form = EventSubtype.objects.create(
label="Subtype with form",
report_person_form=self.report_person_form,
visibility=EventSubtype.VISIBILITY_ALL,
)
self.subtype_without_form = EventSubtype.objects.create(
label="Subtype without form",
report_person_form=None,
visibility=EventSubtype.VISIBILITY_ALL,
)
self.event_without_form = Event.objects.create(
name="Event",
start_time=timezone.now() + timezone.timedelta(days=3),
end_time=timezone.now() + timezone.timedelta(days=3, hours=4),
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.subtype_without_form,
organizer_person=self.organizer,
)
self.upcomint_event = Event.objects.create(
name="Upcoming",
start_time=timezone.now() + timezone.timedelta(days=3),
end_time=timezone.now() + timezone.timedelta(days=3, hours=4),
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.subtype_with_form,
organizer_person=self.organizer,
)
self.past_event = Event.objects.create(
name="Past",
start_time=timezone.now() - timezone.timedelta(days=3),
end_time=timezone.now() - timezone.timedelta(days=2),
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.subtype_with_form,
organizer_person=self.organizer,
)
self.too_old_event = Event.objects.create(
name="Too old",
start_time=timezone.now() - timezone.timedelta(days=9),
end_time=timezone.now() - timezone.timedelta(days=8),
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.subtype_with_form,
organizer_person=self.organizer,
)
def create_reservation(start_time, end_time):
Printer3D.objects.create(name="S1", location="U1", model="Ultimaker", status="F")
user = User.objects.create_user("User", "*****@*****.**", "unsecure_pass")
user.save()
Quota3D.objects.create(user=user, max_time_reservation=40, max_number_of_reservations=2, can_print=True)
Reservation3D.objects.create(user=user, machine=Printer3D.objects.get(name="S1"),
start_time=pytz.timezone(timezone.get_default_timezone_name()).localize(
start_time),
end_time=pytz.timezone(timezone.get_default_timezone_name()).localize(end_time),
event=None)
return Reservation3D.objects.first()
def parse_date(self, date_string, null=True):
if date_string:
date = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S.%f")
date = pytz.timezone(timezone.get_default_timezone_name()).localize(date, is_dst=False)
elif null is False:
# For fields that don't allow null values, set to epoch
date = datetime.utcfromtimestamp(0)
date = pytz.timezone(timezone.get_default_timezone_name()).localize(date, is_dst=False)
else:
date = None
return date
def convert_yearmonth_to_fulldate(from_yearmonth, to_yearmonth):
format_str = '%Y%m' # The input format
from_datetime_obj = datetime.datetime.strptime(str(from_yearmonth),
format_str)
from_datetime_obj = from_datetime_obj.replace(day=1)
to_datetime_obj = datetime.datetime.strptime(str(to_yearmonth), format_str)
from_datetime_obj = pytz.timezone(
timezone.get_default_timezone_name()).localize(from_datetime_obj)
to_datetime_obj = pytz.timezone(
timezone.get_default_timezone_name()).localize(to_datetime_obj)
last_day = calendar.monthrange(to_datetime_obj.year,
to_datetime_obj.month)[1]
to_datetime_obj = to_datetime_obj.replace(day=last_day)
return from_datetime_obj, to_datetime_obj
def setUp(self):
self.unrelated_person = Person.objects.create_person(
email="*****@*****.**",
create_role=True,
)
self.organizer = Person.objects.create_person(
email="*****@*****.**",
create_role=True,
)
start_time = timezone.now() + timezone.timedelta(days=3)
end_time = timezone.now() + timezone.timedelta(days=3, hours=4)
self.a_subtype = EventSubtype.objects.create(
visibility=EventSubtype.VISIBILITY_ALL,
label="A subtype",
type=EventSubtype.TYPE_PUBLIC_ACTION,
)
self.event = Event.objects.create(
name="Event",
start_time=start_time,
end_time=end_time,
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.a_subtype,
organizer_person=self.organizer,
)
self.project = Projet.objects.create(titre="Project",
type=TypeProjet.choices[0][0],
event=self.event)
self.event_wo_project = Event.objects.create(
name="Event without project",
start_time=start_time,
end_time=end_time,
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.a_subtype,
organizer_person=self.organizer,
)
image = Image.new("RGB", (100, 100))
tmp_file = tempfile.NamedTemporaryFile(suffix=".jpg")
image.save(tmp_file)
tmp_file.seek(0)
self.valid_data = {
"type": EventProjectSerializer.Meta.valid_document_types[0],
"name": "A document",
"description": "A description",
"file": tmp_file,
}
def parse_date(self, date_string, null=True):
if date_string:
date = datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S.%f")
date = pytz.timezone(
timezone.get_default_timezone_name()).localize(date,
is_dst=False)
elif null is False:
# For fields that don't allow null values, set to epoch
date = datetime.utcfromtimestamp(0)
date = pytz.timezone(
timezone.get_default_timezone_name()).localize(date,
is_dst=False)
else:
date = None
return date
def setUpClass(cls):
super(FormsTestCase, cls).setUpClass()
fake = Factory.create()
call_command('migrate', verbosity=0)
call_command('fake', verbosity=0)
cls.c = HttpClient()
fake_user = fake.simple_profile()
cls.credentials = {
'username': fake_user['username'],
'password': fake.password()
}
cls.user = User.objects.create_user(
is_superuser=True, **cls.credentials)
cls.settings_template = {
'first_name': 'User',
'last_name': 'Name',
'email': '*****@*****.**',
'dashboard_refresh_rate': '',
'language': 'en',
'timezone': timezone.get_default_timezone_name(),
'next': '/user/settings/'
}
def api_root(request):
utc_offset = tz.get_default_timezone().utcoffset(datetime.now())
utc_offset = utc_offset.total_seconds() / (60*60)
links = {
'self': {
'href': APIUris.get_uri('api-root', req=request,
absolute=True)
},
'apiusers': {
'href': APIUris.get_uri('apiusers-list', req=request,
absolute=True)
},
'bibs': {
'href': APIUris.get_uri('bibs-list', req=request,
absolute=True)
},
'marc': {
'href': APIUris.get_uri('marc-list', req=request,
absolute=True)
},
'items': {
'href': APIUris.get_uri('items-list', req=request,
absolute=True)
},
'eresources': {
'href': APIUris.get_uri('eresources-list', req=request,
absolute=True)
},
'locations': {
'href': APIUris.get_uri('locations-list', req=request,
absolute=True)
},
'itemtypes': {
'href': APIUris.get_uri('itemtypes-list', req=request,
absolute=True)
},
'itemstatuses': {
'href': APIUris.get_uri('itemstatuses-list', req=request,
absolute=True)
},
'callnumbermatches': {
'href': APIUris.get_uri('callnumbermatches-list', req=request,
absolute=True)
},
'firstitemperlocation': {
'href': APIUris.get_uri('firstitemperlocation-list', req=request,
absolute=True)
},
}
ret_val = OrderedDict()
ret_val['catalogApi'] = OrderedDict()
ret_val['catalogApi']['version'] = '1'
ret_val['catalogApi']['_links'] = OrderedDict(sorted(links.items()))
ret_val['serverTime'] = {
'currentTime': tz.now(),
'timezone': tz.get_default_timezone_name(),
'utcOffset': utc_offset
}
return Response(ret_val)
def get_timezone(zip_code):
# first need to get the lat, lng
conn = httplib.HTTPConnection("maps.googleapis.com")
conn.request("GET", "/maps/api/geocode/json?address=%s&sensor=false" % str(zip_code))
resp = conn.getresponse()
if resp.status == 200:
data = json.loads(resp.read())
conn.close();
if data['status'] == 'OK':
location = data['results'][0]['geometry']['location']
#get timezone based on geolocation
conn = httplib.HTTPSConnection("maps.googleapis.com")
conn.request("GET", "/maps/api/timezone/json?location=%s,%s×tamp=%s&sensor=false" % (location['lat'], location['lng'], time.mktime(datetime.utcnow().timetuple())))
resp = conn.getresponse()
if resp.status == 200:
data = json.loads(resp.read())
if data['status'] == 'OK':
try:
return pytz.timezone(data['timeZoneId'])
except Exception:
pass # don't do anythin we will just use the default
else:
conn.close()
return pytz.timezone(timezone.get_default_timezone_name())
def process_checkin(self, dict):
# Scraper base class has different keys than those used in this command.
# Translate and then process the attrs to add/update the django account, if required.
attrs = {}
attrs[USERNAME_KEY] = dict[CHECKIN_USERNAME_KEY]
attrs[DJANGO_USERNAME_KEY] = dict[CHECKIN_DJANGO_USERNAME_KEY]
attrs[USERNUM_KEY] = dict[CHECKIN_USERID_KEY]
attrs[FIRSTNAME_KEY] = dict.get(CHECKIN_FIRSTNAME_KEY, "")
attrs[LASTNAME_KEY] = dict.get(CHECKIN_LASTNAME_KEY, "")
attrs[EMAIL_KEY] = dict.get(CHECKIN_EMAIL_KEY, "")
django_user = self.process_attrs(attrs)
# Since it's not possible to get non-overlapping info from checkinanalytics.php
# we check to see if we've already recorded the checkin. If not, we create it.
checkin_dt_str = dict[CHECKIN_DATE_KEY] + " " + dict[CHECKIN_TIME_KEY]
checkin_dt = datetime.strptime(checkin_dt_str, "%m/%d/%Y %I:%M %p")
checkin_dt = timezone(get_default_timezone_name()).localize(checkin_dt)
try:
VisitEvent.objects.get(who=django_user.member, when=checkin_dt)
except VisitEvent.DoesNotExist:
VisitEvent.objects.create(
who=django_user.member,
when=checkin_dt,
event_type=VisitEvent.EVT_ARRIVAL,
method=METHOD_CODES[dict[CHECKIN_TYPE_KEY]],
sync1=True, # Because we're synching FROM xerocraft.org, it already has this event.
)
def get_date_string(self):
# set locale for displaying day name in french
locale.setlocale(locale.LC_ALL, "fr_FR.utf8")
format = "%A %d %B À %-H:%M"
if self.event.timezone != timezone.get_default_timezone_name():
format += "%Z"
return self.event.local_start_time.strftime(format).capitalize()
def get_timezone(zip_code):
# first need to get the lat, lng
conn = httplib.HTTPConnection("maps.googleapis.com")
conn.request(
"GET",
"/maps/api/geocode/json?address=%s&sensor=false" % str(zip_code))
resp = conn.getresponse()
if resp.status == 200:
data = json.loads(resp.read())
conn.close()
if data['status'] == 'OK':
location = data['results'][0]['geometry']['location']
#get timezone based on geolocation
conn = httplib.HTTPSConnection("maps.googleapis.com")
conn.request(
"GET",
"/maps/api/timezone/json?location=%s,%s×tamp=%s&sensor=false"
% (location['lat'], location['lng'],
time.mktime(datetime.utcnow().timetuple())))
resp = conn.getresponse()
if resp.status == 200:
data = json.loads(resp.read())
if data['status'] == 'OK':
try:
return pytz.timezone(data['timeZoneId'])
except Exception:
pass # don't do anythin we will just use the default
else:
conn.close()
return pytz.timezone(timezone.get_default_timezone_name())
def setUp(self):
self.unrelated_person = Person.objects.create_person(
email="*****@*****.**",
create_role=True,
)
self.organizer = Person.objects.create_person(
email="*****@*****.**",
create_role=True,
)
start_time = timezone.now() + timezone.timedelta(days=3)
end_time = timezone.now() + timezone.timedelta(days=3, hours=4)
self.a_subtype = EventSubtype.objects.create(
visibility=EventSubtype.VISIBILITY_ALL,
label="A subtype",
type=EventSubtype.TYPE_PUBLIC_ACTION,
)
self.event = Event.objects.create(
name="Event",
start_time=start_time,
end_time=end_time,
timezone=timezone.get_default_timezone_name(),
for_users=Event.FOR_USERS_ALL,
subtype=self.a_subtype,
organizer_person=self.organizer,
)
self.project = Projet.objects.create(titre="Project",
type=TypeProjet.choices[0][0],
event=self.event)
def local_to_date(date):
"""
Converts an unlocalized date to a localized date by assuming it is in the default server timezone
:param date: The date to localize
:return: The localized date
"""
return pytz.timezone(timezone.get_default_timezone_name()).localize(date)
def test_set_timezone(self):
"Ensure time zone is correct before, during and after a set request"
self.assertEqual(
timezone.get_current_timezone_name(), timezone.get_default_timezone_name()
)
data = {
"timezone": "Australia/Sydney",
}
self.post("set-timezone", data=data, follow=True)
self.assertResponseContains(
'<option value="Australia/Sydney" selected>Sydney</option>'
)
self.assertEqual(
timezone.get_current_timezone_name(), timezone.get_default_timezone_name()
)
def now(self):
now = timezone.now()
now = datetime.datetime(now.year, 9, 15, 0, 0)
# subtract a year if we're adding people with this script in the spring
if now.month < 6:
now = now - datetime.timedelta(days=365)
pytz.timezone(timezone.get_default_timezone_name()).localize(now)
return now
class Settings(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
dashboard_refresh_rate = models.DurationField(
verbose_name=_('Refresh rate'),
help_text=_('This setting will only be used when a browser does not '
'support refresh on focus.'),
blank=True,
null=True,
default=timezone.timedelta(minutes=1),
choices=[
(None, _('disabled')),
(timezone.timedelta(minutes=1), _('1 min.')),
(timezone.timedelta(minutes=2), _('2 min.')),
(timezone.timedelta(minutes=3), _('3 min.')),
(timezone.timedelta(minutes=4), _('4 min.')),
(timezone.timedelta(minutes=5), _('5 min.')),
(timezone.timedelta(minutes=10), _('10 min.')),
(timezone.timedelta(minutes=15), _('15 min.')),
(timezone.timedelta(minutes=30), _('30 min.')),
])
dashboard_hide_empty = models.BooleanField(
verbose_name=_('Hide Empty Dashboard Cards'),
default=False,
editable=True)
language = models.CharField(choices=settings.LANGUAGES,
default=settings.LANGUAGE_CODE,
max_length=255,
verbose_name=_('Language'))
timezone = models.CharField(choices=tuple(
zip(pytz.common_timezones, pytz.common_timezones)),
default=timezone.get_default_timezone_name(),
max_length=100,
verbose_name=_('Timezone'))
def __str__(self):
return str(format_lazy(_('{user}\'s Settings'), user=self.user))
def api_key(self, reset=False):
"""
Get or create an API key for the associated user.
:param reset: If True, delete the existing key and create a new one.
:return: The user's API key.
"""
if reset:
Token.objects.get(user=self.user).delete()
return Token.objects.get_or_create(user=self.user)[0]
@property
def dashboard_refresh_rate_milliseconds(self):
"""
Convert seconds to milliseconds to be used in a Javascript setInterval
function call.
:return: the refresh rate in milliseconds or None.
"""
if self.dashboard_refresh_rate:
return self.dashboard_refresh_rate.seconds * 1000
return None
def localize(datetime_obj):
try:
default_timezone = timezone.get_default_timezone_name()
aware_datetime = pytz.timezone(default_timezone).localize(datetime_obj)
except ValueError as e:
if 'Not naive datetime' not in str(e):
raise ValueError(e)
aware_datetime = datetime_obj
return aware_datetime
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
kwargs.update({
'initial': {
'language_code': self.request.LANGUAGE_CODE,
'timezone': timezone.get_default_timezone_name()
}
})
return kwargs
def _print_begin_end(self, obj):
local_name = timezone.get_default_timezone_name()
self.stdout.write(" from UTC {utcd}, {local} {locald}".format(
local=local_name,
utcd=obj.date_begin.astimezone(timezone.utc),
locald=timezone.localtime(obj.date_begin)))
self.stdout.write(" to UTC {utcd}, {local} {locald}".format(
local=local_name,
utcd=obj.date_end.astimezone(timezone.utc),
locald=timezone.localtime(obj.date_end)))
def test_format_reservation_start_end_same_day(self):
reservation = self.create_reservation(datetime(2017, 12, 25, 12), datetime(2017, 12, 25, 18))
self.assertEqual(ReservationCalendarComponentView.format_reservation(reservation, pytz.timezone(
timezone.get_default_timezone_name()).localize(datetime(2017, 12, 25))), {
'reservation': reservation,
'start_percentage': 50,
'start_time': "11:00",
'end_time': "17:00",
'length': 25
})
def test_format_reservation_start_day_before(self):
reservation = self.create_reservation(datetime(2017, 12, 24, 12), datetime(2017, 12, 25, 6))
self.assertEqual(ReservationCalendarComponentView.format_reservation(reservation, pytz.timezone(
timezone.get_default_timezone_name()).localize(datetime(2017, 12, 25))), {
'reservation': reservation,
'start_percentage': 0,
'start_time': "00:00",
'end_time': "05:00",
"length": 25
})
def clean(self, value):
value = super(TzAwareTimeField, self).to_python(value)
time_zone = timezone.get_default_timezone_name()
dt = datetime.now()
dt = pytz.timezone(time_zone).localize(dt)
dt = dt.replace(hour=value.hour,
minute=value.minute,
second=value.second,
microsecond=value.microsecond)
return dt
def test_format_reservation_end_day_after(self):
reservation = self.create_reservation(datetime(2017, 12, 25, 12), datetime(2017, 12, 26, 3))
self.assertEqual(ReservationCalendarComponentView.format_reservation(reservation, pytz.timezone(
timezone.get_default_timezone_name()).localize(datetime(2017, 12, 25))), {
'reservation': reservation,
'start_percentage': 50,
'start_time': '11:00',
'end_time': "23:59",
'length': 50 - 100 / 1440
})
def test_user_settings_timezone(self):
self.c.login(**self.credentials)
self.assertEqual(timezone.get_default_timezone_name(), "US/Eastern")
params = self.settings_template.copy()
params["timezone"] = "US/Pacific"
page = self.c.post("/user/settings/", data=params, follow=True)
self.assertEqual(page.status_code, 200)
self.assertEqual(timezone.get_current_timezone_name(),
params["timezone"])
def test_format_reservation_end_day_after(self):
date = pytz.timezone(timezone.get_default_timezone_name()).localize(
datetime.combine(timezone.now().date() + timedelta(days=1), datetime.min.time()))
reservation = self.create_reservation(date + timedelta(hours=12), date + timedelta(days=1, hours=4))
self.assertEqual(ReservationCalendarComponentView.format_reservation(reservation, date), {
'reservation': reservation,
'start_percentage': 50,
'start_time': '11:00',
'end_time': "23:59",
'length': 50 - 100 / 1440
})
def __init__(self, *args, **kwargs):
common_timezone_names = [
tz.replace('_', ' ') for tz in common_timezones
]
the_kwargs = {
'choices': zip(common_timezones, common_timezone_names),
'default': timezone.get_default_timezone_name(),
'max_length': 50,
}
the_kwargs.update(kwargs)
super().__init__(*args, **the_kwargs)
def test_format_reservation_start_day_before(self):
date = pytz.timezone(timezone.get_default_timezone_name()).localize(
datetime.combine(timezone.now().date() + timedelta(days=1), datetime.min.time()))
reservation = self.create_reservation(date + timedelta(hours=12), date + timedelta(days=1, hours=6))
self.assertEqual(ReservationCalendarComponentView.format_reservation(reservation, date + timedelta(days=1)), {
'reservation': reservation,
'start_percentage': 0,
'start_time': "00:00",
'end_time': "05:00",
"length": 25
})
def handle(self, *args, **options):
term = Term.objects.get(value=settings.CURRENT_TERM)
date_max = datetime.now()
pytz.timezone(timezone.get_default_timezone_name()).localize(date_max)
date_list = [date_max - timedelta(hours=x) for x in range(24, 0, -1)]
courses = Course.objects.filter(term=term)
updates = UpdateLog.objects.all().order_by('-time_created')[:10][::-1] # reversed
self.graph_query_history(date_list)
#self.graph_seats_history(date_list, courses, term)
self.graph_update_changes(updates)
def test_timezone_in_email_body(self, mock_seafevents_api):
assert timezone.get_default_timezone_name() == 'Asia/Shanghai'
mock_seafevents_api.get_user_activities_by_timestamp.return_value = self._repo_evs(
)
UserOptions.objects.set_file_updates_email_interval(
self.user.email, 30)
self.assertEqual(len(mail.outbox), 0)
call_command('send_file_updates')
self.assertEqual(len(mail.outbox), 1)
assert '2018-11-05 14:46:02' in mail.outbox[0].body
def graph_update_changes(self, logs):
self.stdout.write('Generating update history graph')
updated = []
added = []
times = []
self.print_progress(len(times), len(logs))
for log in logs:
time = log.time_created.astimezone(pytz.timezone(timezone.get_default_timezone_name()))
times.append(time)
updated.append(log.courses_updated)
added.append(log.courses_added)
self.print_progress(len(times), len(logs))
self.render_graph('Recent course updates', 'course_updates.svg', times, {'Courses Added': added, 'Courses Updated': updated})
class ReserveMachineForm(forms.Form):
def __init__(self, *args, **kwargs):
reason = kwargs.pop('reason', None)
until = kwargs.pop('until', None)
username = kwargs.pop('username', None)
super(ReserveMachineForm, self).__init__(*args, **kwargs)
self.fields['reason'].initial = reason
if until is not None:
self.fields['until'].initial = date_format(
until, format=settings.SHORT_DATE_FORMAT)
self.fields['username'].initial = username
reason = forms.CharField(
widget=forms.Textarea(attrs={'class': 'form-control'}),
help_text='Please provide a reason why you reserve this machine.')
until = forms.DateField(
widget=forms.TextInput(attrs={
'id': 'datepicker',
'size': '10',
'class': 'form-control'
}),
help_text="Format: YYYY-MM-DD (TZ: " +
timezone.get_default_timezone_name() +
"). Type '9999-12-31' for infinite reservation (superusers only).")
username = forms.CharField(widget=forms.HiddenInput(), required=False)
def clean(self):
cleaned_data = super(ReserveMachineForm, self).clean()
reserved_until = cleaned_data.get('until')
if not reserved_until:
# return due to further checks which needs datetime object
return
if reserved_until == datetime.date.max:
pass
elif reserved_until <= datetime.datetime.now().date():
self.add_error(
'until',
"Reservation date must be in the future (min. 1 day).")
elif reserved_until > (datetime.datetime.now().date() +
datetime.timedelta(days=90)):
self.add_error('until',
"Reservation period is limited (max. 90 days).")
def populate_pre_fix_3363_user_status_changes(apps, schema_editor):
User = apps.get_model("cyclos", "User")
UserStatusChangeHistory = apps.get_model("cyclos",
"UserStatusChangeHistory")
users = User.objects.all()
timestamp = pytz.timezone(timezone.get_default_timezone_name()).localize(
datetime.datetime(2016, 12, 31, 23, 59, 59))
for user in users:
if not user.is_active:
user_history = UserStatusChangeHistory.objects.filter(user=user)
if user_history.count() == 0:
UserStatusChangeHistory.objects.create(
user=user,
change_author=None,
timestamp=timestamp.astimezone(pytz.utc),
activate=False)
def question_score(question):
creation_date = question.pub_date
score = question.total_points
answers_positive_points = list(question.answer_set.all().values_list(
'answervote__value', flat=True)).count(True)
answers_negative_points = list(question.answer_set.all().values_list(
'answervote__value', flat=True)).count(False)
score = score * 2 + answers_positive_points - answers_negative_points
reference_date = pytz.timezone(
timezone.get_default_timezone_name()).localize(datetime(1970, 1, 1))
difference = creation_date - reference_date
difference_seconds = difference.days * 86400 + difference.seconds +\
(float(difference.microseconds) / 1000000)
order = log(max(abs(score), 1), 10)
sign = 1 if score > 0 else -1 if score < 0 else 0
seconds = difference_seconds - 1134028003
return round(sign * order + seconds / 45000, 7)
def middleware(request):
tzinfo = get_timezone_from_request(request)
if tzinfo is not None:
logger.debug(
'Activating user timezone "%s" for this request.', tzinfo)
request.tzinfo = tzinfo
timezone.activate(tzinfo)
response = get_response(request)
if tzinfo is not None:
logger.debug(
'Forcibly reset the timezone from "%s" back to "%s".',
request.tzinfo, timezone.get_default_timezone_name())
timezone.deactivate()
return response
def eventpage(request, eid):
uid = None
user = None
if request.user.is_authenticated():
uid = request.user.id
user = request.user
e = get_object_or_404(Event, pk=eid)
if request.method == 'POST':
add_reservation = AddReservation(uid=uid, eid=eid, data=request.POST)
if add_reservation.is_valid():
res = add_reservation.save(commit = False)
rtime = res.begin
pytz.timezone(timezone.get_default_timezone_name()).localize(rtime)
if res.day >= e.start and res.day+timedelta(days=res.duration) <= e.end:
res.event_id = eid
res.save()
e = get_object_or_404(Event, pk=eid)
allres = Reservation.objects.filter(event_id=eid, day__gte = datetime.now()).order_by('day') #
resform = AddReservation(uid=uid, eid=eid)
context = {'user':user, 'event':e, 'add_reservation':resform,'allres':allres}
if uid == e.userid:
edit_event = EditEvent(e=e)
context.update({'edit_event':edit_event})
return render(request, 'event/eventpage.html', context) #
else:
return HttpResponse('reservatino outside of resource time range.')
else:
print add_reservation.errors
elif uid == e.userid:
e = get_object_or_404(Event, pk=eid)
edit_event = EditEvent(e=e)
add_reservation = AddReservation(uid=uid, eid=eid)
allres = Reservation.objects.filter(event_id=eid, day__gte = datetime.now()) #
return render(request, 'event/eventpage.html', {'user':user, 'event': e, 'add_reservation':add_reservation, 'allres':allres, 'edit_event':edit_event})
else:
e = get_object_or_404(Event, pk=eid)
add_reservation = AddReservation(uid=uid, eid=eid)
allres = Reservation.objects.filter(event_id=eid, day__gte = datetime.now()) #
return render(request, 'event/eventpage.html', {'user':user, 'event': e, 'add_reservation':add_reservation, 'allres':allres})
def testTimeZone(self):
#tzname = request.session.get('django_timezone')
response = self.client.get('/')
self.failUnlessEqual(response.status_code, status.HTTP_200_OK)
# If not loggedin, no timezone in session
session = self.client.session
self.assertFalse('django_timezone' in session)
ok = self.client.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
response = self.client.get('/')
self.failUnlessEqual(response.status_code, status.HTTP_200_OK)
# Default Time zone
session = self.client.session
self.assertTrue('django_timezone' in session)
self.assertEqual(session["django_timezone"],
timezone.get_default_timezone_name())
self.client.logout()
u4 = user_model.objects.create_user(username='******',
email='*****@*****.**',
password='******')
u4.name = 'New York Dude'
u4.time_zone = 'America/New_York'
u4.is_active = True
u4.save()
ok = self.client.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
response = self.client.get('/')
self.failUnlessEqual(response.status_code, status.HTTP_200_OK)
# Default Time zone
session = self.client.session
self.assertTrue('django_timezone' in session)
self.assertEqual(session["django_timezone"],
timezone.get_current_timezone_name())
self.assertEqual(timezone.get_current_timezone_name(),
'America/New_York')
self.client.logout()
def question_score(question):
creation_date = question.pub_date
score = question.total_points
answers_positive_points = list(
question.answer_set.all().values_list(
'answervote__value', flat=True)).count(True)
answers_negative_points = list(
question.answer_set.all().values_list(
'answervote__value', flat=True)).count(False)
score = score * 2 + answers_positive_points - answers_negative_points
reference_date = pytz.timezone(
timezone.get_default_timezone_name()).localize(datetime(1970, 1, 1))
difference = creation_date - reference_date
difference_seconds = difference.days * 86400 + difference.seconds +\
(float(difference.microseconds) / 1000000)
order = log(max(abs(score), 1), 10)
sign = 1 if score > 0 else -1 if score < 0 else 0
seconds = difference_seconds - 1134028003
return round(sign * order + seconds / 45000, 7)
def get_options_from(context):
if context.use_tz or tz.get_current_timezone_name() != tz.get_default_timezone_name():
timezone = tz.get_current_timezone()
else:
timezone = None
options = {
'caseless': False,
'safe': not context.autoescape,
'application': context.current_app,
'timezone': timezone,
'language': None if not context.use_i18n else (get_language(), get_language_bidi()),
'formats': None if not context.use_l10n else {
# TODO:
# 'NUMBER_GROUPING': ...,
# 'DECIMAL_SEPARATOR': ...,
# 'THOUSAND_SEPARATOR': ...,
},
}
return options
def testTimeZone(self):
#tzname = request.session.get('django_timezone')
response = self.client.get('/')
self.failUnlessEqual(response.status_code, status.HTTP_200_OK)
# If not loggedin, no timezone in session
session = self.client.session
self.assertFalse('django_timezone' in session)
ok = self.client.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
response = self.client.get('/')
self.failUnlessEqual(response.status_code, status.HTTP_200_OK)
# Default Time zone
session = self.client.session
self.assertTrue('django_timezone' in session)
self.assertEqual(session["django_timezone"], timezone.get_default_timezone_name())
self.client.logout()
u4 = user_model.objects.create_user(username='******', email='*****@*****.**', password='******')
u4.name = 'New York Dude'
u4.time_zone = 'America/New_York'
u4.is_active = True
u4.save()
ok = self.client.login(email='*****@*****.**', password='******')
self.assertTrue(ok)
response = self.client.get('/')
self.failUnlessEqual(response.status_code, status.HTTP_200_OK)
# Default Time zone
session = self.client.session
self.assertTrue('django_timezone' in session)
self.assertEqual(session["django_timezone"], timezone.get_current_timezone_name())
self.assertEqual(timezone.get_current_timezone_name(), 'America/New_York')
self.client.logout()
def test_get_default_timezone(self):
self.assertEqual(timezone.get_default_timezone_name(), 'America/Chicago')
def to_date_with_tz(dt):
tz = timezone.get_default_timezone_name()
return pytz.timezone(tz).localize(dt)
def convert_datetime(dt):
dt = pytz.timezone(timezone.get_default_timezone_name()).localize(dt)
return dt
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "todoapp1.settings." + os.environ.get("ENVIRONMENT", "MUST-SET-ENVIRONMENT-VARIABLE-SEE-README"))
import django
django.setup()
from django.conf import settings
from todoapp1.backend1 import api as backend
from django.utils import timezone
from django.templatetags.tz import localtime
from todoapp1.backend1.utils import dt_server_now, dt_server_to_local, dt_local_to_server
print 'USE_TZ', settings.USE_TZ
print 'DEFAULT TIMEZONE', settings.TIME_ZONE
print 'get_current_timezone()', timezone.get_current_timezone_name(), timezone.get_current_timezone()
print 'get_default_timezone()', timezone.get_default_timezone_name(), timezone.get_default_timezone()
NOW = dt_server_now()
NOW_DT = NOW
NOW_STR = NOW_DT.strftime("%Y-%m-%dT%H:%M:%S")
NOWL_DT = dt_server_to_local(NOW)
NOWL_STR = dt_server_to_local(NOW).strftime("%Y-%m-%dT%H:%M:%S")
print '1. SERVER NOW_DT ', NOW_DT
print '1. SERVER NOW_STR', NOW_STR
print '1. LOCAL NOW_DT ', NOWL_DT
print '1. LOCAL NOW_STR ', NOWL_STR
print '2. LOCAL NOWL_STR', NOWL_STR
print '2. SERVER NOW_DT ', dt_local_to_server(NOWL_STR)
def ThreadMain(self,ProcName):
logging.info('Starting ' + ProcName)
TimeZone = timezone.get_default_timezone_name()
self.tz=pytz.timezone(TimeZone)
METS_NAMESPACE = SchemaProfile.objects.get(entity = 'mets_namespace').value
METS_SCHEMALOCATION = SchemaProfile.objects.get(entity = 'mets_schemalocation').value
METS_PROFILE = SchemaProfile.objects.get(entity = 'mets_profile').value
XLINK_NAMESPACE = SchemaProfile.objects.get(entity = 'xlink_namespace').value
XSI_NAMESPACE = SchemaProfile.objects.get(entity = 'xsi_namespace').value
while 1:
if self.mDieFlag==1: break # Request for death
self.mLock.acquire()
self.Time,self.Run = ESSDB.DB().action('ESSProc','GET',('Time','Run'),('Name',ProcName))[0]
if self.Run == '0':
logging.info('Stopping ' + ProcName)
ESSDB.DB().action('ESSProc','UPD',('Status','0','Run','0','PID','0'),('Name',ProcName))
self.RunFlag=0
self.mLock.release()
if Debug: logging.info('RunFlag: 0')
time.sleep(2)
continue
# Process Item
lock=thread.allocate_lock()
Cmets_obj = Parameter.objects.get(entity='content_descriptionfile').value
self.IngestTable = ESSDB.DB().action('ESSConfig','GET',('Value',),('Name','IngestTable'))[0][0]
self.PolicyTable = ESSDB.DB().action('ESSConfig','GET',('Value',),('Name','PolicyTable'))[0][0]
if ExtDBupdate:
self.ext_IngestTable = self.IngestTable
else:
self.ext_IngestTable = ''
self.dbget,errno,why = ESSDB.DB().action(self.IngestTable,'GET4',('ObjectIdentifierValue',
'ObjectUUID',
'PolicyId',
'ObjectSize'),
('StatusProcess','BETWEEN',39,'AND',40,'AND',
'StatusActivity','=','0'))
if errno: logging.error('Failed to access Local DB, error: ' + str(why))
for self.obj in self.dbget:
self.ok = 1
self.ProcDB = ESSDB.DB().action('ESSProc','GET',('Run','Pause'),('Name',ProcName))[0]
if self.ProcDB[0]=='0':
logging.info('Stopping ' + ProcName)
ESSDB.DB().action('ESSProc','UPD',('Status','0','Run','0','PID','0'),('Name',ProcName))
thread.interrupt_main()
time.sleep(5)
break
elif self.ProcDB[1]==1:
while 1:
time.sleep(60)
self.ProcDB = ESSDB.DB().action('ESSProc','GET',('Run','Pause'),('Name',ProcName))[0]
if self.ProcDB[1]==1:
logging.info('Process is in pause state')
else:
break
self.ObjectIdentifierValue = self.obj[0]
self.ObjectUUID = self.obj[1]
self.PolicyId = self.obj[2]
self.ObjectSize = self.obj[3]
self.PolicyDB,errno,why = ESSDB.DB().action(self.PolicyTable,'GET3',('AIPpath','IngestMetadata','ChecksumAlgorithm','IngestPath'),('PolicyID',self.PolicyId))
if errno:
logging.error('Failed to access Local DB, error: ' + str(why))
self.ok = 0
if self.ok:
###########################################################
# set variables
self.AIPpath = self.PolicyDB[0][0]
self.metatype = self.PolicyDB[0][1]
self.ChecksumAlgorithm = self.PolicyDB[0][2]
self.CA = dict(ChecksumAlgorithm_CHOICES)[self.ChecksumAlgorithm]
self.SIPpath = self.PolicyDB[0][3]
self.p_obj = self.ObjectIdentifierValue + '.tar'
self.ObjectPath = os.path.join(self.AIPpath,self.p_obj)
self.SIProotpath = os.path.join(self.SIPpath,self.ObjectIdentifierValue)
if self.metatype in [4]:
#self.Cmets_obj = '%s/%s_Content_METS.xml' % (self.ObjectIdentifierValue,self.ObjectIdentifierValue)
#self.Cmets_objpath = os.path.join(self.SIPpath,self.Cmets_obj)
#self.Cmets_obj = Cmets_obj.replace('{uuid}',self.ObjectIdentifierValue)
self.Cmets_obj = Cmets_obj.replace('{objid}',self.ObjectIdentifierValue)
self.Cmets_objpath = os.path.join(self.SIProotpath,self.Cmets_obj)
elif self.metatype in [1,2,3]:
self.Cmets_obj = '%s_Content_METS.xml' % (self.ObjectIdentifierValue)
self.Cmets_objpath = os.path.join(self.AIPpath,self.Cmets_obj)
self.Pmets_obj = '%s_Package_METS.xml' % (self.ObjectIdentifierValue)
self.Pmets_objpath = os.path.join(self.AIPpath,self.Pmets_obj)
self.AIC_UUID = None
self.AIC_UUID_rel_ObjectUUIDs = []
if self.ok:
METS_agent_list = []
METS_altRecordID_list = []
if self.metatype == 1:
############################################
# Object have metatype 1 (METS)
self.METS_LABEL = 'ESSArch AIP'
# Get SIP Content METS information
self.METSfilepath = os.path.join(self.SIPpath,self.ObjectIdentifierValue + '/metadata/SIP/' + self.ObjectIdentifierValue + '_Content_METS.xml')
res_info, res_files, res_struct, error, why = ESSMD.getMETSFileList(FILENAME=self.METSfilepath)
for agent in res_info[2]:
if not (agent[0] == 'CREATOR' and agent[3] == 'SOFTWARE'):
METS_agent_list.append(agent)
METS_agent_list.append(['CREATOR','INDIVIDUAL','',AgentIdentifierValue,[]])
METS_agent_list.append(['CREATOR', 'OTHER', 'SOFTWARE', 'ESSArch', ['VERSION=%s' % ProcVersion]])
elif self.metatype == 2:
############################################
# Object have metatype 2 (RES)
self.METS_LABEL = 'Imaging AIP RA'
METS_agent_list.append(['ARCHIVIST','ORGANIZATION','','Riksarkivet',[]])
METS_agent_list.append(['CREATOR','ORGANIZATION','','Riksarkivet',[]])
METS_agent_list.append(['CREATOR','INDIVIDUAL','',AgentIdentifierValue,[]])
METS_agent_list.append(['CREATOR', 'OTHER', 'SOFTWARE', 'ESSArch', ['VERSION=%s' % ProcVersion]])
elif self.metatype == 3:
############################################
# Object have metatype 3 (ADDML)
self.METS_LABEL = 'Born Digital AIP RA'
METS_agent_list.append(['ARCHIVIST','ORGANIZATION','','Riksarkivet',[]])
METS_agent_list.append(['CREATOR','ORGANIZATION','','Riksarkivet',[]])
METS_agent_list.append(['CREATOR','INDIVIDUAL','',AgentIdentifierValue,[]])
METS_agent_list.append(['CREATOR', 'OTHER', 'SOFTWARE', 'ESSArch', ['VERSION=%s' % ProcVersion]])
elif self.metatype in [4]:
############################################
# Object have metatype 4 (eARD METS)
res_info, res_files, res_struct, error, why = ESSMD.getMETSFileList(FILENAME=self.Cmets_objpath)
for agent in res_info[2]:
#if not (agent[0] == 'CREATOR' and agent[3] == 'SOFTWARE'):
METS_agent_list.append(agent)
self.METS_LABEL = res_info[0][0]
METS_agent_list.append(['CREATOR',None, 'INDIVIDUAL',None,AgentIdentifierValue,[]])
METS_agent_list.append(['CREATOR',None, 'OTHER', 'SOFTWARE', 'ESSArch', ['VERSION=%s' % ProcVersion]])
for altRecordID in res_info[3]:
METS_altRecordID_list.append(altRecordID)
logging.debug('self.obj: '+str(self.obj))
if self.ChecksumAlgorithm > 0: #self.ChecksumAlgorithm 1 = MD5, 2 = SHA-256
self.startCalTime = datetime.timedelta(seconds=time.localtime()[5],minutes=time.localtime()[4],hours=time.localtime()[3])
errno,why = ESSPGM.DB().SetAIPstatus(self.IngestTable, self.ext_IngestTable, AgentIdentifierValue, self.ObjectUUID, 40, 5)
if errno: logging.error('Failed to update DB status for AIP: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
logging.info('Start create Package METS for: ' + self.ObjectIdentifierValue)
if self.ok:
###########################################################
# Create PMETS for AIP package
self.M_CHECKSUM, errno, why = ESSPGM.Check().checksum(self.Cmets_objpath,self.CA)
if errno:
self.event_info = 'Problem to get checksum for METS object for AIP package: ' + str(self.Cmets_objpath)
logging.error(self.event_info)
ESSPGM.Events().create('1030','','ESSArch AIPCreator',ProcVersion,'1',self.event_info,2,self.ObjectIdentifierValue)
self.ok = 0
self.M_statinfo = os.stat(self.Cmets_objpath)
self.M_SIZE = self.M_statinfo.st_size
self.M_utc_mtime = datetime.datetime.utcfromtimestamp(self.M_statinfo.st_mtime).replace(tzinfo=pytz.utc)
self.M_lociso_mtime = self.M_utc_mtime.astimezone(self.tz).isoformat()
self.P_CHECKSUM, errno, why = ESSPGM.Check().checksum(self.ObjectPath,self.CA)
if errno:
self.event_info = 'Problem to get checksum for AIP package: ' + str(self.ObjectPath)
logging.error(self.event_info)
ESSPGM.Events().create('1040','','ESSArch AIPChecksum',ProcVersion,'1',self.event_info,2,self.ObjectIdentifierValue)
self.ok = 0
self.P_statinfo = os.stat(self.ObjectPath)
self.P_SIZE = self.P_statinfo.st_size
self.P_utc_mtime = datetime.datetime.utcfromtimestamp(self.P_statinfo.st_mtime).replace(tzinfo=pytz.utc)
self.P_lociso_mtime = self.P_utc_mtime.astimezone(self.tz).isoformat()
if self.metatype in [1,2,3]:
self.PMETSdoc = ESSMD.createPMets(
ID=self.ObjectIdentifierValue,
LABEL=self.METS_LABEL,
AGENT=METS_agent_list,
P_SIZE=self.P_SIZE,
P_CREATED=self.P_lociso_mtime,
P_CHECKSUM=self.P_CHECKSUM,
P_CHECKSUMTYPE=self.CA,
M_SIZE=self.M_SIZE,
M_CREATED=self.M_lociso_mtime,
M_CHECKSUM=self.M_CHECKSUM,
M_CHECKSUMTYPE=self.CA,
)
errno,why = ESSMD.writeToFile(self.PMETSdoc,self.Pmets_objpath)
if errno:
self.event_info = 'Problem to write PMETS to file for AIP package: ' + str(self.Pmets_objpath)
logging.error(self.event_info)
ESSPGM.Events().create('1040','','ESSArch AIPChecksum',ProcVersion,'1',self.event_info,2,self.ObjectIdentifierValue)
time.sleep(2)
self.ok = 0
elif self.metatype in [4]:
ms_files = []
ms_files.append(['amdSec', None, 'techMD', 'techMD001', None,
None, 'ID%s' % str(uuid.uuid1()), 'URL', 'file:%s/%s' % (self.ObjectIdentifierValue,self.Cmets_obj), 'simple',
self.M_CHECKSUM, self.CA, self.M_SIZE, 'text/xml', self.M_lociso_mtime,
'OTHER', 'METS', None])
ms_files.append(['fileSec', None, None, None, None,
None, 'ID%s' % str(uuid.uuid1()), 'URL', 'file:%s' % self.p_obj, 'simple',
self.P_CHECKSUM, self.CA, self.P_SIZE, 'application/x-tar', self.P_lociso_mtime,
'tar', 'techMD001', None])
# define namespaces
self.namespacedef = 'xmlns:mets="%s"' % METS_NAMESPACE
self.namespacedef += ' xmlns:xlink="%s"' % XLINK_NAMESPACE
self.namespacedef += ' xmlns:xsi="%s"' % XSI_NAMESPACE
self.namespacedef += ' xsi:schemaLocation="%s %s"' % (METS_NAMESPACE, METS_SCHEMALOCATION)
errno,info_list = ESSMD.Create_IP_mets(ObjectIdentifierValue = self.ObjectIdentifierValue,
METS_ObjectPath = self.Pmets_objpath,
agent_list = METS_agent_list,
altRecordID_list = METS_altRecordID_list,
file_list = ms_files,
namespacedef = self.namespacedef,
METS_LABEL = self.METS_LABEL,
METS_PROFILE = METS_PROFILE,
METS_TYPE = 'AIP',
METS_DocumentID = self.Pmets_obj,
TimeZone = TimeZone)
if errno:
logging.error('Problem to create Package METS file, why: %s' % str(info_list))
self.ObjectMessageDigest = self.P_CHECKSUM
self.stopCalTime = datetime.timedelta(seconds=time.localtime()[5],minutes=time.localtime()[4],hours=time.localtime()[3])
self.CalTime = self.stopCalTime-self.startCalTime
self.ObjectSizeMB = self.ObjectSize/1048576
if self.CalTime.seconds < 1: self.CalTime = datetime.timedelta(seconds=1) #Fix min time to 1 second if it is zero.
self.CalMBperSEC = int(self.ObjectSizeMB)/int(self.CalTime.seconds)
logging.info('Finished calculate checksum: ' + self.ObjectIdentifierValue + ' , ' + str(self.CalMBperSEC) + ' MB/Sec and Time: ' + str(self.CalTime))
if self.ok:
self.timestamp_utc = datetime.datetime.utcnow().replace(microsecond=0,tzinfo=pytz.utc)
self.timestamp_dst = self.timestamp_utc.astimezone(self.tz)
res,errno,why = ESSDB.DB().action(self.IngestTable,'UPD',('ObjectMessageDigestAlgorithm',self.ChecksumAlgorithm,
'ObjectMessageDigest',self.ObjectMessageDigest,
'MetaObjectSize',self.M_SIZE,
'LastEventDate',self.timestamp_utc.replace(tzinfo=None),
'linkingAgentIdentifierValue',AgentIdentifierValue,
'LocalDBdatetime',self.timestamp_utc.replace(tzinfo=None)),
('ObjectIdentifierValue',self.ObjectIdentifierValue))
if errno: logging.error('Failed to update Local DB: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
if errno == 0 and ExtDBupdate:
ext_res,ext_errno,ext_why = ESSMSSQL.DB().action(self.IngestTable,'UPD',('ObjectMessageDigestAlgorithm',self.ChecksumAlgorithm,
'ObjectMessageDigest',self.ObjectMessageDigest,
'MetaObjectSize',self.M_SIZE,
'LastEventDate',self.timestamp_dst.replace(tzinfo=None),
'linkingAgentIdentifierValue',AgentIdentifierValue),
('ObjectIdentifierValue',self.ObjectIdentifierValue))
if ext_errno: logging.error('Failed to update External DB: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(ext_why))
else:
res,errno,why = ESSDB.DB().action(self.IngestTable,'UPD',('ExtDBdatetime',self.timestamp_utc.replace(tzinfo=None)),('ObjectIdentifierValue',self.ObjectIdentifierValue))
if errno: logging.error('Failed to update Local DB: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
if self.ok and self.metatype == 4:
####################################################
# Create AIC METS File:
aic_obj = ArchiveObject.objects.filter(relaic_set__UUID=self.ObjectUUID)[:1]
if aic_obj:
self.AIC_UUID = aic_obj.get().ObjectUUID
logging.info('Succeeded to get AIC_UUID: %s from DB' % self.AIC_UUID)
else:
logging.warning('AIC not found for IP object: %s, skip to create AIC METS file' % self.ObjectUUID)
if self.ok and self.AIC_UUID:
ip_obj_list = ArchiveObject.objects.filter(Q(StatusProcess=3000) | Q(ObjectUUID=self.ObjectUUID), reluuid_set__AIC_UUID=self.AIC_UUID).order_by('Generation')
if ip_obj_list:
logging.info('Start create AIC METS: ' + self.AIC_UUID)
self.AICmets_objpath = os.path.join(self.AIPpath,self.AIC_UUID + '_AIC_METS.xml')
ms_files = []
for ip_obj in ip_obj_list:
logging.info('Add IP: %s to AIC METS: %s' % (ip_obj.ObjectUUID,self.AIC_UUID))
ms_files.append(['fileSec', None, None, None, None,
None, 'ID%s' % str(uuid.uuid1()), 'URL', 'file:%s' % ip_obj.ObjectUUID, 'simple',
ip_obj.ObjectMessageDigest, dict(ChecksumAlgorithm_CHOICES)[ip_obj.ObjectMessageDigestAlgorithm], ip_obj.ObjectSize, 'application/x-tar', ip_obj.CreateDate,
'IP Package', None, None])
# define namespaces
self.namespacedef = 'xmlns:mets="%s"' % METS_NAMESPACE
self.namespacedef += ' xmlns:xlink="%s"' % XLINK_NAMESPACE
self.namespacedef += ' xmlns:xsi="%s"' % XSI_NAMESPACE
self.namespacedef += ' xsi:schemaLocation="%s %s"' % (METS_NAMESPACE, METS_SCHEMALOCATION)
errno,info_list = ESSMD.Create_IP_mets(ObjectIdentifierValue = self.AIC_UUID,
METS_ObjectPath = self.AICmets_objpath,
agent_list = [],
altRecordID_list = [],
file_list = ms_files,
namespacedef = self.namespacedef,
METS_LABEL = 'AIC relation to IP',
METS_PROFILE = METS_PROFILE,
METS_TYPE = 'AIC',
METS_DocumentID = self.AIC_UUID + '_AIC_METS.xml',
TimeZone = TimeZone)
if errno:
logging.error('Problem to create AIC METS file, why: %s' % str(info_list))
else:
logging.error('Problem to get objects related to AIC_UUID: %s from DB' % (self.AIC_UUID))
self.ok = 0
if self.ok:
errno,why = ESSPGM.DB().SetAIPstatus(self.IngestTable, self.ext_IngestTable, AgentIdentifierValue, self.ObjectUUID, 49, 0)
if errno:
logging.error('Failed to update DB status for AIP: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
else:
self.event_info = 'Succeeded to create checksum for Object: %s' % self.ObjectIdentifierValue
logging.info(self.event_info)
ESSPGM.Events().create('1040','','ESSArch AIPChecksum',ProcVersion,'0',self.event_info,2,self.ObjectIdentifierValue)
else:
errno,why = ESSPGM.DB().SetAIPstatus(self.IngestTable, self.ext_IngestTable, AgentIdentifierValue, self.ObjectUUID, 40, 100)
if errno:
logging.error('Failed to update DB status for AIP: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
else:
self.event_info = 'Failed to create checksum for Object: %s' % self.ObjectIdentifierValue
logging.error(self.event_info)
ESSPGM.Events().create('1040','','ESSArch AIPChecksum',ProcVersion,'1',self.event_info,2,self.ObjectIdentifierValue)
elif self.ChecksumAlgorithm == 0: #self.ChecksumAlgorithm 0 = No checksum
logging.info('Skip creation of checksum: ' + self.ObjectIdentifierValue)
self.ObjectMessageDigest = ''
self.MetaObjectSize = os.stat(self.Cmets_objpath)[6]
self.timestamp_utc = datetime.datetime.utcnow().replace(microsecond=0,tzinfo=pytz.utc)
self.timestamp_dst = self.timestamp_utc.astimezone(self.tz)
res,errno,why = ESSDB.DB().action(self.IngestTable,'UPD',('ObjectMessageDigestAlgorithm',self.ChecksumAlgorithm,
'ObjectMessageDigest',self.ObjectMessageDigest,
'StatusProcess','49',
'StatusActivity','0',
'MetaObjectSize',self.MetaObjectSize,
'LastEventDate',self.timestamp_utc.replace(tzinfo=None),
'linkingAgentIdentifierValue',AgentIdentifierValue,
'LocalDBdatetime',self.timestamp_utc.replace(tzinfo=None)),
('ObjectIdentifierValue',self.ObjectIdentifierValue))
if errno: logging.error('Failed to update Local DB: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
else: ESSPGM.Events().create('1040','','ESSArch AIPChecksum',ProcVersion,'0','Skip creation of checksum',2,self.ObjectIdentifierValue)
if errno == 0 and ExtDBupdate:
ext_res,ext_errno,ext_why = ESSMSSQL.DB().action(self.IngestTable,'UPD',('ObjectMessageDigestAlgorithm',self.ChecksumAlgorithm,
'ObjectMessageDigest',self.ObjectMessageDigest,
'StatusProcess','49',
'StatusActivity','0',
'MetaObjectSize',self.MetaObjectSize,
'LastEventDate',self.timestamp_dst.replace(tzinfo=None),
'linkingAgentIdentifierValue',AgentIdentifierValue),
('ObjectIdentifierValue',self.ObjectIdentifierValue))
if ext_errno: logging.error('Failed to update External DB: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(ext_why))
else:
res,errno,why = ESSDB.DB().action(self.IngestTable,'UPD',('ExtDBdatetime',self.timestamp_utc.replace(tzinfo=None)),('ObjectIdentifierValue',self.ObjectIdentifierValue))
if errno: logging.error('Failed to update Local DB: ' + str(self.ObjectIdentifierValue) + ' error: ' + str(why))
db.close_old_connections()
self.mLock.release()
time.sleep(int(self.Time))
self.mDieFlag=0
