def create(self, request, *args, **kwargs): if request.user.is_authenticated(): obj_content_type = ContentType.objects.get_for_model(BillSegment) obj = Comment() obj.content_type = obj_content_type obj.user = request.user obj.comment = request.data['comment'] obj.object_pk = request.data['object_pk'] obj.site_id = settings.SITE_ID obj.save() return Response(status=201) elif request.data['token']: token = Token.objects.get(key=request.data['token']) obj_content_type = ContentType.objects.get_for_model(BillSegment) obj = Comment() obj.content_type = obj_content_type obj.user = token.user obj.comment = request.data['comment'] obj.object_pk = request.data['object_id'] obj.site_id = settings.SITE_ID obj.save() serializer = CommentsSerializer(obj) return JSONResponse(serializer.data, status=201) else: return Response(serializer._errors, status=status.HTTP_400_BAD_REQUEST)
def post(request): """Returns a serialized object""" data = json.loads(request.body)["body"] guid = data.get("guid", None) res = Result() if guid: obj = getObjectsFromGuids([guid])[0] comment = Comment() comment.comment = data.get("comment", "No comment") comment.user = request.user comment.user_name = request.user.get_full_name() comment.user_email = request.user.email comment.content_object = obj # For our purposes, we never have more than one site comment.site_id = 1 comment.save() obj.comment_count += 1 obj.save() emailComment(comment, obj, request) res.append(commentToJson(comment)) return JsonResponse(res.asDict())
def post(request): """Returns a serialized object""" data = request.POST or json.loads(request.body)['body'] guid = data.get('guid', None) res = Result() if guid: obj = getObjectsFromGuids([guid,])[0] comment = Comment() comment.comment = data.get('comment', 'No comment') comment.user = request.user comment.user_name = request.user.get_full_name() comment.user_email = request.user.email comment.content_object = obj comment.site_id = get_current_site(request).id comment.save() obj.comment_count += 1 obj.save() emailComment(comment, obj, request) res.append(commentToJson(comment)) return JsonResponse(res.asDict())
def handle(self, *args, **options): # Get apps with a status of PENDING or QUESTION for partners with a status of AVAILABLE # where the editor has not agreed to the terms of use. pending_apps = (Application.objects.filter( status__in=[Application.PENDING, Application.QUESTION], partner__status__in=[Partner.AVAILABLE], editor__isnull=False, editor__user__userprofile__terms_of_use=False, ).exclude(editor__user__groups__name="restricted").order_by( "status", "partner", "date_created")) # Loop through the apps and add a comment if twl_team hasn't commented already or if the app hasn't had comments # in 8 days or more. for app in pending_apps: if (Comment.objects.filter( Q(object_pk=str(app.pk), site_id=settings.SITE_ID), (Q(user=twl_team) | Q(submit_date__gte=(timezone.now() - timedelta(days=8)))), ).count() == 0): comment = Comment( content_object=app, site_id=settings.SITE_ID, user=twl_team, # Translators: This comment is added to pending applications when our terms of use change. comment=_( "Our terms of use have changed. " "Your applications will not be processed until you log in and agree to our updated terms." ), ) comment.save()
def test_to_table_reviewed(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) unit2 = utils.create_unit() fault2 = fault_utils.create_fault(unit=unit2) fault_rev = fault_utils.create_fault_review(fault=fault2) comment = Comment(submit_date=timezone.now(), user=fault_rev.reviewed_by, content_object=fault_rev.fault, comment="comment", site=get_current_site(None)) comment.save() rep = faults.FaultSummaryReport( report_opts={'review_status': "reviewed"}) rep.report_format = "csv" context = rep.get_context() table = rep.to_table(context) header_row = table.index([ _("Fault ID"), _("Occurred"), _("Site"), _("Unit"), _("Fault Type"), _("Modality"), _("Link"), ]) # should be one fault after header assert len(table[header_row + 1:]) == 1
def set_comment(node_handle, comment): """ Sets the comment string as a comment for the provided node_handle. """ content_type = ContentType.objects.get_for_model(NodeHandle) object_pk = node_handle.pk user = get_user() site_id = django_settings.SITE_ID c = Comment(content_type=content_type, object_pk=object_pk, user=user, site_id=site_id, comment=comment) c.save()
def get_context_data(self, **kwargs): context = super(TaskDetailView, self).get_context_data(**kwargs) task = self.object # merge actions and comments actions = task.action_object_actions.all() task_content_type = ContentType.objects.get_for_model(self.model) comments = list(Comment.objects\ .filter(content_type=task_content_type, object_pk=task.id)\ .select_related('user')) # get the annotation for the particular task try: task_annotation = task.annotation except Annotation.DoesNotExist: task_annotation = None # for the annotation that is linked to the task, get all the replies if task_annotation: # get the replies to the annotation annotation_replies = Annotation.objects.filter(in_reply_to=task_annotation)\ .select_related('created_by_user') comments.extend([ Comment(user=a.created_by_user, comment=a.text, submit_date=a.created_at) for a in annotation_replies ]) context['task_timeline'] = sorted( chain(comments, actions), key=lambda x: x.submit_date if hasattr(x, 'comment') else x.timestamp) context['possible_workflows'] = Workflow.objects.unclosed().filter( country=task.country, locality=task.locality).all() # warn when submitting task on behalf of another user Task.decorate_submission_message([task], self) Task.decorate_potential_assignees([task], self.country) Task.decorate_permissions([task], self) # add work to context if task.work: context['work'] = task.work context['work_json'] = json.dumps( WorkSerializer(instance=task.work, context={ 'request': self.request }).data) return context
def create(self, request, *args, **kwargs): if request.user.is_authenticated(): obj_content_type = ContentType.objects.get_for_model(BillSegment) obj = Comment() obj.content_type = obj_content_type obj.user = request.user obj.comment = request.data['comment'] obj.object_pk = request.data['object_pk'] obj.site_id = settings.SITE_ID obj.save() return Response(status=201) else: return Response(status=403)
def create_new_sequence(requestsid, created, modified, snex2_param, users, notes, db_session, active=True): newobsgroup = ObservationGroup(name=str(requestsid), created=created, modified=modified) newobsgroup.save() cadence_strategy = snex2_param['cadence_strategy'] cadence_params = {'cadence_frequency': snex2_param['cadence_frequency']} newcadence = DynamicCadence(cadence_strategy=cadence_strategy, cadence_parameters=cadence_params, active=active, created=created, modified=modified, observation_group_id=newobsgroup.id) newcadence.save() ### Check if there are any SNEx1 comments associated with this ### observation request, and if so, save them in SNEx2 comment = db_session.query(notes).filter( and_(notes.tablename == 'obsrequests', notes.tableid == requestsid)).first() if comment: usr = db_session.query(users).filter( users.id == comment.userid).first() snex2_user = User.objects.get(username=usr.name) content_type_id = ContentType.objects.get(model='observationgroup').id newcomment = Comment(object_pk=newobsgroup.id, user_name=snex2_user.username, user_email=snex2_user.email, comment=comment.note, submit_date=comment.posttime, is_public=True, is_removed=False, content_type_id=content_type_id, site_id=2, user_id=snex2_user.id) newcomment.save() return newobsgroup
def save_valid_fault_form(form, request): """helper for EditFault, CreateFault, and create_ajax for processing FaultForm""" fault = form.save(commit=False) if not fault.id: fault.created_by = request.user fault.modified_by = request.user fault.save() new_faults = set(models.FaultType.objects.filter(code__in=form.cleaned_data['fault_types_field'])) cur_faults = set(fault.fault_types.all()) to_remove = cur_faults - new_faults to_add = new_faults - cur_faults fault.fault_types.remove(*to_remove) fault.fault_types.add(*to_add) related_service_events = form.cleaned_data.get('related_service_events', []) sers = sl_models.ServiceEvent.objects.filter(pk__in=related_service_events) fault.related_service_events.set(sers) comment = form.cleaned_data.get('comment', '') if comment: comment = Comment( submit_date=timezone.now(), user=request.user, content_object=fault, comment=comment, site=get_current_site(request) ) comment.save() for f in request.FILES.getlist('fault-attachments'): Attachment.objects.create( attachment=f, comment="Uploaded %s by %s" % (timezone.now(), request.user.username), label=f.name, fault=fault, created_by=request.user ) a_ids = [a for a in request.POST.getlist('fault-attachments_delete_ids', '') if a] if a_ids: Attachment.objects.filter(id__in=a_ids).delete() return fault
def post(self, request, *args, **kwargs): task = self.get_object() user = self.request.user task.updated_by_user = user task_content_type = ContentType.objects.get_for_model(task) comment_text = request.POST.get('comment', None) if task.customised: # redirect to custom close url, if necessary if self.change == 'close' and task.customised.close_url(): return redirect(task.customised.close_url()) for change, verb in Task.VERBS.items(): if self.change == change: state_change = getattr(task, change) if not has_transition_perm(state_change, self): raise PermissionDenied if comment_text: comment = Comment(user=user, object_pk=task.id, user_name=user.get_full_name() or user.username, user_email=user.email, comment=comment_text, content_type=task_content_type, site_id=get_current_site(request).id) state_change(user, comment=comment.comment) # save the comment here so that it appears after the action comment.submit_date = now() comment.save() else: state_change(user) if change == 'submit': verb = 'submitted for review' if change == 'unsubmit': verb = 'returned with changes requested' messages.success(request, "Task '%s' has been %s" % (task.title, verb)) task.save() return redirect(self.get_redirect_url())
def test_to_table(self): site = USite.objects.create(name="site") unit1 = utils.create_unit(site=site) fault_utils.create_fault(unit=unit1) unit2 = utils.create_unit() fault2 = fault_utils.create_fault(unit=unit2) usa2 = sl_utils.create_unit_service_area(unit=unit2) sl_utils.create_service_event(unit_service_area=usa2) se2 = sl_utils.create_service_event(unit_service_area=usa2) fault2.related_service_events.add(se2) user = sl_utils.create_user() comment = Comment(submit_date=timezone.now(), user=user, content_object=fault2, comment="comment", site=get_current_site(None)) comment.save() rep = faults.FaultDetailsReport( report_opts={'review_status': 'unreviewed'}) rep.report_format = "csv" context = rep.get_context() table = rep.to_table(context) header_row = table.index([ _("Fault ID"), _("Occurred"), _("Site"), _("Unit"), _("Fault Type"), _("Modality"), _("Created By"), _("Created Date"), _("Modified By"), _("Modified Date"), _("Reviewed By"), _("Reviewed Date"), _("Related Service Events"), _("Link"), ]) # should be three faults after header assert len(table[header_row + 1:]) == 2
def test_generate_html(self): site = USite.objects.create(name="site") unit = utils.create_unit(site=site) utc = utils.create_unit_test_collection(unit=unit) utils.create_test_list_instance(unit_test_collection=utc) unit2 = utils.create_unit(site=None) utc2 = utils.create_unit_test_collection(unit=unit2) tli2 = utils.create_test_list_instance(unit_test_collection=utc2) comment = Comment( submit_date=timezone.now(), user=tli2.created_by, content_object=tli2, comment='test comment', site=Site.objects.latest("pk"), ) comment.save() rep = qc.TestListInstanceDetailsReport( report_opts={'unit_test_collection': [utc.pk]}) rep.report_format = "pdf" rep.to_html()
def post(self, request, *args, **kwargs): form = HelpDeskForm(request.POST) if kwargs: pk = kwargs['pk'] requesteduser = HelpDeskModel.objects.get(id=pk).name_Request.id content = ContentType.objects.get_for_model(HelpDeskModel) current_site = get_current_site(request) # Add a comment to the issue thread create_first_note = Comment( content_type=content, object_pk=request.POST['object_pk'], site=current_site, user=request.user, user_name=request.user.get_full_name(), user_email=request.user.email, user_url='http://dummyurl.com', comment=request.POST['comment'], submit_date=datetime.now(), ip_address='127.0.0.1', ) create_first_note.save() return redirect('HelpDesk', pk) else: if form.is_valid(): f = form.save(commit=False) f.name_Request = request.user f.save() message = Mail( from_email='*****@*****.**', to_emails=['*****@*****.**'], subject='HelpDesk Request', html_content="A new helpdesk complaint has been filed by.") sg = SendGridAPIClient(SENDGRID_API_KEY) # sg.send(message) messages.success(request, "Your request has been submitted.") return redirect('HelpDesk', f.id)
def add_new_note(self, request, resource_type, resource_id): resource = request.resource if request.POST: #title = request.REQUEST.get('title'); body = request.REQUEST.get('body') new_comment = Comment(content_object=resource, site=DjangoSite.objects.all()[0], user=request.user, user_name=request.user.username, user_email=request.user.email, user_url='', comment=body, ip_address=None, is_public=True, is_removed=False) new_comment.save() return self.response_success() return HttpResponse('')
def getGetApproveURL(self): c = Comment(id=12345) self.assertEqual(django_comments.get_approve_url(c), "/approve/12345/")
def getGetDeleteURL(self): c = Comment(id=12345) self.assertEqual(django_comments.get_delete_url(c), "/delete/12345/")
def testGetFlagURL(self): c = Comment(id=12345) self.assertEqual(django_comments.get_flag_url(c), "/flag/12345/")
def get_comments(targetid, tablename, notes, users, days_ago): content_dict = { 'targets': ContentType.objects.get(model='target').id, 'obsrequests': ContentType.objects.get(model='observationgroup').id, 'spec': ContentType.objects.get(model='reduceddatum').id } with get_session(db_address=_SNEX1_DB) as db_session: if targetid == 'all': comments = db_session.query(notes).filter( and_(notes.tablename == tablename, notes.datecreated > days_ago)) else: comments = db_session.query(notes).filter( and_(notes.targetid == targetid, notes.tablename == tablename, notes.datecreated > days_ago)) for comment in comments: usr = db_session.query(users).filter( users.id == comment.userid).first() snex2_user = User.objects.get(username=usr.name) target_id = comment.targetid if tablename == 'targets': # Check if it already exists in SNEx2 old_comment = Comment.objects.filter( object_pk=target_id, comment=comment.note, content_type_id=content_dict[tablename]).first() if old_comment: continue newcomment = Comment( object_pk=target_id, user_name=snex2_user.username, user_email=snex2_user.email, comment=comment.note, submit_date=comment.posttime, is_public=True, is_removed=False, content_type_id=content_dict[tablename], site_id=2, #TODO: Why? user_id=snex2_user.id) newcomment.save() elif tablename == 'obsrequests': # Need to get the observationgroup id given its name obsgroup = ObservationGroup.objects.filter( name=str( comment.tableid)) #TODO: Check if should be str or int if obsgroup.count() > 0: newcomment = Comment( object_pk=obsgroup.first().id, user_name=snex2_user.username, user_email=snex2_user.email, comment=comment.note, submit_date=comment.posttime, is_public=True, is_removed=False, content_type_id=content_dict[tablename], site_id=2, #TODO: Why? user_id=snex2_user.id) newcomment.save() elif tablename == 'spec': # Need to get reduceddatum id from the reduceddatumextra table rdes = ReducedDatumExtra.objects.filter( data_type='spectroscopy', key='snex_id', target_id=int(comment.targetid)) snex2_id = False for rde in rdes: if int(comment.tableid) == json.loads( rde.value)['snex_id']: snex2_id = json.loads(rde.value)['snex2_id'] break if snex2_id: # Check if it already exists in SNEx2 old_comment = Comment.objects.filter( object_pk=snex2_id, comment=comment.note, content_type_id=content_dict[tablename]).first() if old_comment: continue newcomment = Comment( object_pk=snex2_id, user_name=snex2_user.username, user_email=snex2_user.email, comment=comment.note, submit_date=comment.posttime, is_public=True, is_removed=False, content_type_id=content_dict[tablename], site_id=2, #TODO: Why? user_id=snex2_user.id) newcomment.save() print('Done ingesting comments for target {} and table {}'.format( targetid, tablename))
def handle(self, *args, **options): ### Define our db tables as Classes obsrequests = load_table('obsrequests', db_address=_SNEX1_DB) obslog = load_table('obslog', db_address=_SNEX1_DB) obstags = load_table('obsrequests_tags', db_address=_SNEX1_DB) tags = load_table('tags', db_address=_SNEX1_DB) Groups = load_table('groups', db_address=_SNEX1_DB) users = load_table('users', db_address=_SNEX1_DB) notes = load_table('notes', db_address=_SNEX1_DB) #print('Made tables') with get_session(db_address=_SNEX1_DB) as db_session: ### Make a dictionary of the groups in the SNex1 db snex1_groups = {} for x in db_session.query(Groups): snex1_groups[x.name] = x.idcode ### Get all the currently active sequences onetime_sequence = db_session.query(obsrequests).filter( and_( obsrequests.autostop == 1, obsrequests.approved == 1, or_(obsrequests.sequenceend == '0000-00-00 00:00:00', obsrequests.sequenceend > datetime.datetime.utcnow()))) onetime_sequence_ids = [int(o.id) for o in onetime_sequence] repeating_sequence = db_session.query(obsrequests).filter( and_( obsrequests.autostop == 0, obsrequests.approved == 1, or_(obsrequests.sequenceend == '0000-00-00 00:00:00', obsrequests.sequenceend > datetime.datetime.utcnow()))) repeating_sequence_ids = [int(o.id) for o in repeating_sequence] ### Get pending sequence ids pending_sequence = db_session.query(obsrequests).filter( and_( obsrequests.approved == 0, or_(obsrequests.sequenceend == '0000-00-00 00:00:00', obsrequests.sequenceend > datetime.datetime.utcnow()))) pending_sequence_ids = [int(o.id) for o in pending_sequence] #print('Got active sequences') ### Cancel the SNEx2 sequences that are no longer active in SNEx1 snex2_active_cadences = DynamicCadence.objects.filter(active=True) for cadence in snex2_active_cadences: obsgroupid = int(cadence.observation_group_id) currentobsgroup = ObservationGroup.objects.filter( id=obsgroupid).first() try: snex1id = int(currentobsgroup.name) except: # Name not an integer, so not an observation group from SNEx1 continue if snex1id not in onetime_sequence_ids and snex1id not in repeating_sequence_ids: cadence.active = False cadence.save() ### Look for comments associated with cancellation by ### checking the number of comments in SNEx2 vs SNEx1 content_type_id = ContentType.objects.get( model='observationgroup').id snex2_comment_count = Comment.objects.filter( object_pk=obsgroupid, content_type_id=content_type_id).count() snex1_comment_query = db_session.query(notes).filter( and_(notes.tableid == snex1id, notes.tablename == 'obsrequests')).order_by( notes.id.desc()) snex1_comment_count = snex1_comment_query.count() if snex2_comment_count < snex1_comment_count: cancel_comment = snex1_comment_query.first() usr = db_session.query(users).filter( users.id == cancel_comment.userid).first() snex2_user = User.objects.get(username=usr.name) # Ingest most recent snex1 comment newcomment = Comment( object_pk=obsgroupid, user_name=snex2_user.username, user_email=snex2_user.email, comment=cancel_comment.note, submit_date=cancel_comment.posttime, is_public=True, is_removed=False, content_type_id=content_type_id, site_id=2, user_id=snex2_user.id) newcomment.save() ### Add the sequence end time to the template observationrecord templaterecord = currentobsgroup.observation_records.filter( observation_id='template').first() if templaterecord: templaterecord.parameters[ 'sequence_end'] = datetime.datetime.utcnow( ).strftime('%Y-%m-%dT%H:%M:%S') templaterecord.save() #print('Canceled inactive sequences') #### Check if any of the pending requests in SNEx2 are no longer pending in SNEx1 snex2_pending_cadences = ObservationRecord.objects.filter( observation_id='template pending') for pendingobs in snex2_pending_cadences: currentobsgroup = pendingobs.observationgroup_set.first() try: snex1id = int(currentobsgroup.name) except: # Name not an integer, so not an observation group from SNEx1 continue if snex1id not in pending_sequence_ids: #Was either accepted or rejected pendingobs.observation_id = 'template' pendingobs.save() # Figure out if the pending sequence was accepted or rejected obsgroupid = currentobsgroup.id if snex1id in onetime_sequence_ids or snex1id in repeating_sequence_ids: cadence = DynamicCadence.objects.get( observation_group_id=obsgroupid) cadence.active = True cadence.save() else: ### Look for comments associated with cancellation by ### checking the number of comments in SNEx2 vs SNEx1 content_type_id = ContentType.objects.get( model='observationgroup').id snex2_comment_count = Comment.objects.filter( object_pk=obsgroupid, content_type_id=content_type_id).count() snex1_comment_query = db_session.query(notes).filter( and_(notes.tableid == snex1id, notes.tablename == 'obsrequests')).order_by( notes.id.desc()) snex1_comment_count = snex1_comment_query.count() if snex2_comment_count < snex1_comment_count: cancel_comment = snex1_comment_query.first() usr = db_session.query(users).filter( users.id == cancel_comment.userid).first() snex2_user = User.objects.get(username=usr.name) # Ingest most recent snex1 comment newcomment = Comment( object_pk=obsgroupid, user_name=snex2_user.username, user_email=snex2_user.email, comment=cancel_comment.note, submit_date=cancel_comment.posttime, is_public=True, is_removed=False, content_type_id=content_type_id, site_id=2, user_id=snex2_user.id) newcomment.save() ### Compare the currently active sequences with the ones already in SNEx2 ### to see which ones need to be added and which ones need the newest obs requests onetime_obs_to_add = [] repeating_obs_to_add = [] existing_onetime_obs = [] existing_repeating_obs = [] pending_obs_to_add = [] # Get the observation groups already in SNEx2 existing_obs = [] for o in ObservationGroup.objects.all(): try: existing_obs.append(int(o.name)) except: # Name not a SNEx1 ID, so not in SNEx1 continue for o in onetime_sequence: if int(o.id) not in existing_obs: onetime_obs_to_add.append(o) else: existing_onetime_obs.append(o) for o in repeating_sequence: if int(o.id) not in existing_obs: repeating_obs_to_add.append(o) else: existing_repeating_obs.append(o) for o in pending_sequence: if int(o.id) not in existing_obs: pending_obs_to_add.append(o) ### Add the pending observations not in SNEx2 for obs in pending_obs_to_add: created = obs.datecreated modified = obs.lastmodified target_id = int(obs.targetid) target_query = Target.objects.filter(id=target_id) if not target_query.exists(): print( 'Observation not ingested because target {} does not exist' .format(target_id)) continue requestsid = int(obs.id) if obs.autostop == 0: snex2_param = get_snex2_params(obs, repeating=True) else: snex2_param = get_snex2_params(obs, repeating=False) newobsgroup = create_new_sequence(requestsid, created, modified, snex2_param, users, notes, db_session, active=False) ### Add "template" record snex2_param['sequence_start'] = str(obs.sequencestart).replace( ' ', 'T') snex2_param['sequence_end'] = str(obs.sequenceend).replace( ' ', 'T') snex2_param['start_user'] = db_session.query(users).filter( users.id == obs.userstart).first().firstname rmndr = snex2_param.pop('reminder') template = ObservationRecord(facility='LCO', observation_id='template pending', status='', created=created, modified=modified, target_id=target_id, user_id=2, parameters=snex2_param) template.save() # Save permissions on template if int(obs.groupidcode) is not None: update_permissions(int(obs.groupidcode), template, snex1_groups) #View obs record newobsgroup.observation_records.add(template) count = 0 #print('Getting parameters for new sequences') for sequencelist in [ onetime_obs_to_add, existing_onetime_obs, repeating_obs_to_add, existing_repeating_obs ]: for obs in sequencelist: facility = 'LCO' created = obs.datecreated modified = obs.lastmodified target_id = int(obs.targetid) user_id = 2 #supernova ### Make sure target is in SNEx2 (to avoid ingesting obs for standards) target_query = Target.objects.filter(id=target_id) if not target_query.exists(): print( 'Observation not ingested because target {} does not exist' .format(target_id)) continue ### Get observation id from observation portal API # Query API requestsid = int(obs.id) #print('Querying API for sequence with SNEx1 ID of {}'.format(requestsid)) # Get observation portal requestgroup id from most recent obslog entry for this observation sequence tracknumber_query = db_session.query(obslog).filter( and_(obslog.requestsid == requestsid, obslog.tracknumber > 0)).order_by( obslog.id.desc()) tracknumber_count = tracknumber_query.count() if tracknumber_count > 0: tracknumber = int( tracknumber_query.first().tracknumber) windowstart = Time( tracknumber_query.first().windowstart, format='jd').to_value('isot') windowend = Time(tracknumber_query.first().windowend, format='jd').to_value('isot') # Get the observation portal observation id using this tracknumber headers = { 'Authorization': 'Token {}'.format(os.environ['LCO_APIKEY']) } response = requests.get( 'https://observe.lco.global/api/requestgroups/{}'. format(tracknumber), headers=headers) if not response.json().get('requests'): continue result = response.json()['requests'][0] observation_id = int(result['id']) status = result['state'] #print('The most recent observation request for this sequence has API id {} with status {}'.format(observation_id, status)) #print('and with parameters {}'.format(snex2_param)) else: #print('No requests have been submitted for this sequence yet') observation_id = 0 if count < 2: snex2_param = get_snex2_params(obs, repeating=False) else: snex2_param = get_snex2_params(obs, repeating=True) if observation_id: in_snex2 = bool( ObservationRecord.objects.filter( observation_id=str(observation_id)).count()) #print('Is this observation request in SNEx2? {}'.format(in_snex2)) else: in_snex2 = False ### Add the new cadence, observation group, and observation record to the SNEx2 db try: ### Create new observation group and dynamic cadence, if it doesn't already exist if count == 0 or count == 2: newobsgroup = create_new_sequence(requestsid, created, modified, snex2_param, users, notes, db_session, active=True) ### Add "template" record snex2_param['sequence_start'] = str( obs.sequencestart).replace(' ', 'T') snex2_param['sequence_end'] = str( obs.sequenceend).replace(' ', 'T') snex2_param['start_user'] = db_session.query( users).filter(users.id == obs.userstart).first().firstname rmndr = snex2_param.pop('reminder') template = ObservationRecord( facility='LCO', observation_id='template', status='', created=created, modified=modified, target_id=target_id, user_id=user_id, parameters=snex2_param) template.save() # Save permissions on template if int(obs.groupidcode) is not None: update_permissions( int(obs.groupidcode), template, snex1_groups) #View obs record newobsgroup.observation_records.add(template) ### Add observation science tag to the target in SNEx2, if it doesn't already exist obstagids = [ t.tagid for t in db_session.query(obstags).filter( obstags.requestsid == requestsid).all() ] taglist = [ x.tag for x in db_session.query(tags).filter( tags.id.in_(obstagids)).all() ] for t in taglist: snex2_tag, _ = ScienceTags.objects.get_or_create( tag=t) newtag, created = TargetTags.objects.get_or_create( target_id=target_id, tag_id=int(snex2_tag.id)) ### Add the new observation record, if it exists in SNEx1 but not SNEx2 if tracknumber_count > 0 and observation_id > 0 and not in_snex2: snex2_param['start'] = windowstart snex2_param['end'] = windowend newobs = ObservationRecord( facility=facility, observation_id=str(observation_id), status=status, created=created, modified=modified, target_id=target_id, user_id=user_id, parameters=snex2_param) newobs.save() obs_groupid = int(obs.groupidcode) if obs_groupid is not None: update_permissions( int(obs_groupid), newobs, snex1_groups) #View obs record ### Add observaton record to existing observation group or the one we just made if count == 0 or count == 2: #print('Adding to new observation group') newobsgroup.observation_records.add(newobs) else: oldobsgroup = ObservationGroup.objects.filter( name=str(requestsid)).first() oldobsgroup.observation_records.add(newobs) #print('Added observation record') if in_snex2: #Update the status and start and end times oldobs = ObservationRecord.objects.filter( observation_id=str(observation_id)).order_by( '-id').first() oldobs.status = status oldobs.parameters['reminder'] = snex2_param[ 'reminder'] oldobs.save() except: raise count += 1
def post(self, request, *args, **kwargs): form = HelpDeskForm(request.POST) if kwargs: pk = kwargs['pk'] requesteduser = HelpDeskModel.objects.get(id=pk).name_Request.id content = ContentType.objects.get_for_model(HelpDeskModel) current_site = get_current_site(request) # Add a comment to the issue thread create_first_note = Comment( content_type=content, object_pk=request.POST['object_pk'], site=current_site, user=request.user, user_name=request.user.get_full_name(), user_email=request.user.email, user_url='http://dummyurl.com', comment=request.POST['comment'], submit_date=datetime.now(), ip_address='127.0.0.1', ) create_first_note.save() return redirect('HelpDesk', pk) else: if form.is_valid(): f = form.save(commit=False) f.name_Request = request.user f.save() subject = 'Your email has been logged with HelpDesk' email = str(request.user) try: alumni = Alumni.objects.get(user_id=request.user.id) first_name = alumni.user.first_name context = {'first_name': first_name} admin_context = { 'first_name': first_name, 'protocol': 'https', 'domain': 'murdochdubaicareerportal.com' } htmlText = render_to_string( 'HelpDesk/helpdesk_request_logged.html', context) send_html_mail(subject, htmlText, [email]) subject = 'A new HelpDesk request has been received' htmlText = render_to_string( 'HelpDesk/helpdesk_request_submitted.html', admin_context) send_html_mail(subject, htmlText, [DEFAULT_FROM_EMAIL]) except: pass try: student = Student.objects.get(user_id=request.user.id) first_name = student.user.first_name student_email = str(student.personal_email) context = {'first_name': first_name} admin_context = { 'first_name': first_name, 'protocol': 'https', 'domain': 'murdochdubaicareerportal.com' } htmlText = render_to_string( 'HelpDesk/helpdesk_request_logged.html', context) send_html_mail(subject, htmlText, [email]) send_html_mail(subject, htmlText, [student_email]) subject = 'A new HelpDesk request has been received' htmlText = render_to_string( 'HelpDesk/helpdesk_request_submitted.html', admin_context) send_html_mail(subject, htmlText, [DEFAULT_FROM_EMAIL]) except: pass try: employer = Employer.objects.get(user_id=request.user.id) first_name = employer.company_name context = {'first_name': first_name} admin_context = { 'first_name': first_name, 'protocol': 'https', 'domain': 'murdochdubaicareerportal.com' } htmlText = render_to_string( 'HelpDesk/helpdesk_request_logged.html', context) send_html_mail(subject, htmlText, [email]) subject = 'A new HelpDesk request has been received' htmlText = render_to_string( 'HelpDesk/helpdesk_request_submitted.html', admin_context) send_html_mail(subject, htmlText, [DEFAULT_FROM_EMAIL]) except: pass messages.success(request, "Your request has been submitted.") return redirect('HelpDesk', f.id)
def test_to_table(self): site = USite.objects.create(name="site") unit = utils.create_unit(site=site) utc = utils.create_unit_test_collection(unit=unit) tli = utils.create_test_list_instance(unit_test_collection=utc) # make this tli autoreviewed tli.all_reviewed = True tli.reviewed_by = None tli.save() unit2 = utils.create_unit(site=None) utc2 = utils.create_unit_test_collection(unit=unit2) tli2 = utils.create_test_list_instance(unit_test_collection=utc2) # give tli2 some history tli3 = utils.create_test_list_instance( unit_test_collection=utc2, work_completed=tli2.work_completed - timezone.timedelta(days=2), ) ti = utils.create_test_instance(test_list_instance=tli3) # tli comment comment = Comment( submit_date=timezone.now(), user=tli2.created_by, content_object=tli2, comment='test comment', site=Site.objects.latest("pk"), ) comment.save() attachment = Attachment( attachment=ContentFile("content", "content.pdf"), created_by=tli.created_by, testlistinstance=tli2, ) attachment.save() attachment = Attachment( attachment=ContentFile("content", "content.pdf"), created_by=tli.created_by, testinstance=ti, ) attachment.save() rep = qc.TestListInstanceDetailsReport( report_opts={'unit_test_collection': [utc.pk, utc2.pk]}) rep.report_format = "csv" context = rep.get_context() table = rep.to_table(context) ntlis = table.count([ _('Test'), _('Value'), _('Reference'), _('Tolerance'), _('Pass/Fail'), _('Review Status'), _('Comment'), _('Attachments'), ]) # should be three tlis assert ntlis == 3