/ - Diff - Anotace pro analýzu smluvních podmínek a skrytých reklam (AV ČR) - 0x00 - Redmine

« Předchozí | Další »

Revize 83d4581e

Přidáno uživatelem Vojtěch Bartička před téměř 3 roky(ů)

ID 83d4581e8cc40b7399062a2451cfe1da6145365f
Rodič a49028dd
Potomek 82dede50

Added final annotation endpoints

Backend/Backend/Controllers/AnnotationController.cs
53	53	[HttpGet("/annotation/{annotationId}")]
54	54	[ProducesResponseType((int)HttpStatusCode.OK, Type = typeof(AnnotationInfo))]
55	55	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
56		public ActionResult<AnnotationInfo> GetAnnotation([FromServices] ClientInfo clientInfo, Guid annotationId)
	56	public ActionResult<AnnotationInfo> GetAnnotation([FromServices] ClientInfo clientInfo, Guid annotationId, [FromQuery] bool isFinal)
57	57	{
58	58	if (clientInfo.LoggedUser == null)
59	59	{
...	...
61	61	return Problem();
62	62	}
63	63
	64	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	65	{
	66	Forbid();
	67	}
	68
64	69	// Take care of - non-admin user requesting not-assigned annotation
65	70	// non-existent annotation
66	71	try
67	72	{
68		var res = annotationService.GetAnnotation(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role);
	73	var res = annotationService.GetAnnotation(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, isFinal);
69	74	return Ok(res);
70	75	}
71	76	catch (InvalidOperationException e)
...	...
82	87	[HttpPost("/annotation/{annotationId}")]
83	88	[ProducesResponseType((int)HttpStatusCode.OK)]
84	89	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
85		public ActionResult PostAnnotation([FromServices] ClientInfo clientInfo, Guid annotationId, [FromBody] AnnotationInstanceAddRequest request)
	90	public ActionResult PostAnnotation([FromServices] ClientInfo clientInfo, Guid annotationId, [FromBody] AnnotationInstanceAddRequest request, [FromQuery] bool isFinal)
86	91	{
87	92	if (clientInfo.LoggedUser == null)
88	93	{
89	94	logger.Warning("ClientInfo has null LoggerUser in [Authorized] controller /annotations");
90	95	return Problem();
91	96	}
92
	97
	98	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	99	{
	100	Forbid();
	101	}
	102
93	103	// Take care of - non-admin user requesting not-assigned annotation
94	104	// non-existent annotation
95	105	try
96	106	{
97		annotationService.AddAnnotationInstance(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request);
	107	annotationService.AddAnnotationInstance(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request, isFinal);
98	108	return Ok();
99	109	}
100	110	catch (UnauthorizedAccessException)
...	...
110	120	[HttpDelete("/annotation/{annotationId}/{occurenceId}")]
111	121	[ProducesResponseType((int)HttpStatusCode.OK)]
112	122	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
113		public ActionResult DeleteAnnotationInstance([FromServices] ClientInfo clientInfo, Guid annotationId, Guid occurenceId)
	123	public ActionResult DeleteAnnotationInstance([FromServices] ClientInfo clientInfo, Guid annotationId, Guid occurenceId, [FromQuery] bool isFinal)
114	124	{
115	125	if (clientInfo.LoggedUser == null)
116	126	{
...	...
118	128	return Problem();
119	129	}
120	130
	131	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	132	{
	133	Forbid();
	134	}
	135
121	136	// Take care of - non-admin user requesting not-assigned annotation
122	137	// non-existent annotation
123	138	try
124	139	{
125		annotationService.DeleteAnnotationInstance(annotationId, occurenceId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role);
	140	annotationService.DeleteAnnotationInstance(annotationId, occurenceId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, isFinal);
126	141	return Ok();
127	142	}
128	143	catch (UnauthorizedAccessException)
...	...
140	155	[ProducesResponseType((int)HttpStatusCode.OK)]
141	156	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
142	157	public ActionResult AddNoteToTagOccurence([FromServices] ClientInfo clientInfo, Guid annotationId, Guid occurenceId,
143		[FromBody] AddNoteToTagOccurenceRequest request)
	158	[FromBody] AddNoteToTagOccurenceRequest request, [FromBody] bool isFinal)
144	159	{
145	160	if (clientInfo.LoggedUser == null)
146	161	{
...	...
148	163	return Problem();
149	164	}
150	165
	166	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	167	{
	168	Forbid();
	169	}
	170
151	171	// Take care of - non-admin user requesting not-assigned annotation
152	172	// non-existent annotation
153	173	try
154	174	{
155		tagService.AddNoteToTagInstance(annotationId, occurenceId, clientInfo.LoggedUser, request);
	175	tagService.AddNoteToTagInstance(annotationId, occurenceId, clientInfo.LoggedUser, request, isFinal);
156	176	return Ok();
157	177	}
158	178	catch (InvalidOperationException e)
...	...
169	189	[HttpPost("/annotation/{annotationId}/note")]
170	190	[ProducesResponseType((int)HttpStatusCode.OK)]
171	191	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
172		public ActionResult AddNoteToTagOccurence([FromServices] ClientInfo clientInfo, Guid annotationId, [FromBody] AddNoteToAnnotationRequest request)
	192	public ActionResult AddNoteToTagOccurence([FromServices] ClientInfo clientInfo, Guid annotationId, [FromBody] AddNoteToAnnotationRequest request, [FromQuery] bool isFinal)
173	193	{
174	194	if (clientInfo.LoggedUser == null)
175	195	{
...	...
177	197	return Problem();
178	198	}
179	199
	200	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	201	{
	202	Forbid();
	203	}
	204
180	205	// Take care of - non-admin user requesting not-assigned annotation
181	206	// non-existent annotation
182	207	try
183	208	{
184		annotationService.AddNoteToAnnotation(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request);
	209	annotationService.AddNoteToAnnotation(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request, isFinal);
185	210	return Ok();
186	211	}
187	212	catch (InvalidOperationException e)
...	...
198	223	[HttpPut("/annotation/{annotationId}/{instanceId}/sentiment")]
199	224	[ProducesResponseType((int)HttpStatusCode.OK)]
200	225	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
201		public ActionResult SetTagInstanceSentiment([FromServices] ClientInfo clientInfo, Guid annotationId, Guid instanceId, SetInstanceSentimentRequest request)
	226	public ActionResult SetTagInstanceSentiment([FromServices] ClientInfo clientInfo, Guid annotationId, Guid instanceId, SetInstanceSentimentRequest request, [FromQuery] bool isFinal)
202	227	{
203	228	if (clientInfo.LoggedUser == null)
204	229	{
...	...
206	231	return Problem();
207	232	}
208	233
	234	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	235	{
	236	Forbid();
	237	}
	238
209	239	try
210	240	{
211		annotationService.SetTagInstanceSentiment(annotationId, instanceId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request.Sentiment);
	241
	242	annotationService.SetTagInstanceSentiment(annotationId, instanceId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request.Sentiment, isFinal);
212	243	return Ok();
213	244	}
214	245	catch (InvalidOperationException e)
...	...
225	256	[HttpPut("/annotation/{annotationId}/done")]
226	257	[ProducesResponseType((int)HttpStatusCode.OK)]
227	258	[ProducesResponseType((int)HttpStatusCode.Forbidden)]
228		public ActionResult MarkAsDone([FromServices] ClientInfo clientInfo, Guid annotationId, [FromBody] MarkAnnotationDoneRequest request)
	259	public ActionResult MarkAsDone([FromServices] ClientInfo clientInfo, Guid annotationId, [FromBody] MarkAnnotationDoneRequest request, [FromQuery] bool isFinal)
229	260	{
230	261	if (clientInfo.LoggedUser == null)
231	262	{
...	...
233	264	return Problem();
234	265	}
235	266
	267	if (isFinal && clientInfo.LoggedUser.Role < Models.Enums.ERole.ADMINISTRATOR)
	268	{
	269	Forbid();
	270	}
	271
236	272	try
237	273	{
238		annotationService.MarkAnnotationAsDone(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request.Done);
	274	annotationService.MarkAnnotationAsDone(annotationId, clientInfo.LoggedUser.Id, clientInfo.LoggedUser.Role, request.Done, isFinal);
239	275	return Ok();
240	276	}
241	277	catch (InvalidOperationException e)

                 };
+            }
             public void AddNoteToAnnotation(Guid annotationId, Guid userId, ERole userRole, AddNoteToAnnotationRequest request)
             public void AddNoteToAnnotation(Guid annotationId, Guid userId, ERole userRole, AddNoteToAnnotationRequest request, bool isFinal)
+            {
                 Annotation annotation = null;
                 try
+                {
                     annotation = context.Annotations.Include(a => a.User).First(a => a.Id == annotationId);
                     if (!isFinal)
+                    {
                         annotation = context.Annotations.Include(a => a.User).First(a => a.Id == annotationId);
+                    }
                     else
+                    {
                         annotation = context.FinalAnnotations.Include(a => a.User).First(a => a.Id == annotationId);
+                    }
+                }
                 catch (Exception)
+                {
-...
+            }
             public AnnotationInfo GetAnnotation(Guid annotationId, Guid userId, ERole userRole)
             public AnnotationInfo GetAnnotation(Guid annotationId, Guid userId, ERole userRole, bool isFinal)
+            {
                 var annotation = context.Annotations
                 Annotation annotation = new();
                 if (!isFinal)
+                {
                     annotation = context.Annotations
                     .Where(a => a.Id == annotationId)
                     .Include(a => a.User)
                     .Include(a => a.Document).ThenInclude(d => d.Content)
                     .First();
+                }
                 else
+                {
                     annotation = context.FinalAnnotations
                     .Where(a => a.Id == annotationId)
                     .Include(a => a.User)
                     .Include(a => a.Document).ThenInclude(d => d.Content)
                     .First();
+                }
                 if (userRole < ERole.ADMINISTRATOR)
+                {
-...
+                }
                 var docToRender = "";
                 HTMLService.CachedInfo cachedInfoToReturn = new();
                 HTMLService.CachedInfo cachedInfoToReturn = new();
                 if (annotation.CachedDocumentHTML == "")
+                {
                     var result = htmlService.FullPreprocessHTML(documentContent.Content, tags);
-...
                         TagClosingLengths = JsonConvert.DeserializeObject<List<int>>(annotation.CachedClosingLengths),
                         TagInstanceCSS = JsonConvert.DeserializeObject<List<TagInstanceCSSInfo>>(annotation.CachedCSS)
                     };
                     // The annotation has been modified and we need to either add the new tag or remove the tag
                     if (annotation.ModifiedType != EModified.NONE)
+                    {
-...
                 return text.Contains("<html>");
+            }
             public void AddAnnotationInstance(Guid annotationId, Guid userId, ERole userRole, AnnotationInstanceAddRequest request)
             public void AddAnnotationInstance(Guid annotationId, Guid userId, ERole userRole, AnnotationInstanceAddRequest request, bool isFinal)
+            {
                 var annotation = context.Annotations
                    .Where(a => a.Id == annotationId)
                    .Include(a => a.User)
                    .Include(a => a.Document).ThenInclude(d => d.Content)
                    .First();
                 Annotation annotation = new();
                 if (!isFinal)
+                {
                     annotation = context.Annotations
                         .Where(a => a.Id == annotationId)
                         .Include(a => a.User)
                         .Include(a => a.Document).ThenInclude(d => d.Content)
                         .First();
+                }
                 else
+                {
                     annotation = context.FinalAnnotations
                         .Where(a => a.Id == annotationId)
                         .Include(a => a.User)
                         .Include(a => a.Document).ThenInclude(d => d.Content)
                         .First();
+                }
                 if (userRole < ERole.ADMINISTRATOR)
+                {
-...
+                    }
+                }
                 AnnotationTag annotationTag = new()
                 AnnotationTag annotationTag = new()
+                {
                     Id = Guid.NewGuid(),
                     Annotation = annotation,
-...
                     SelectedText = request.SelectedText,
                     Note = ""
                 };
                 if (annotation.State == EState.NEW)
                     annotation.State = EState.IN_PROGRESS;
+                }
                 AnnotationTagGeneric annotationTag = new();
                 if (isFinal)
+                {
                     annotationTag = new FinalAnnotationTag()
+                    {
                         Id = Guid.NewGuid(),
                         Annotation = annotation as FinalAnnotation,
                         Instance = request.InstanceId == null ? Guid.NewGuid() : request.InstanceId.Value,
                         Length = request.Length,
                         Position = request.Position,
                         SelectedText = request.SelectedText,
                         Note = ""
                     };
+                }
                 else
+                {
                     annotationTag = new AnnotationTag()
+                    {
                         Id = Guid.NewGuid(),
                         Annotation = annotation as Annotation,
                         Instance = request.InstanceId == null ? Guid.NewGuid() : request.InstanceId.Value,
                         Length = request.Length,
                         Position = request.Position,
                         SelectedText = request.SelectedText,
                         Note = ""
                     };
+                }
                 if (request.Type == ETagType.TAG)
+                {
-...
                 annotation.LastModifiedTagId = annotationTag.Id;
                 annotation.ModifiedType = EModified.ADDED;
                 context.AnnotationTags.Add(annotationTag);
                 if (isFinal)
+                {
                     context.FinalAnnotationTags.Add(annotationTag as FinalAnnotationTag);
+                }
                 else
+                {
                     context.AnnotationTags.Add(annotationTag as AnnotationTag);
+                }
                 context.SaveChanges();
+            }
             public void DeleteAnnotationInstance(Guid annotationId, Guid tagInstanceId, Guid loggedUserId, ERole userRole)
             public void DeleteAnnotationInstance(Guid annotationId, Guid tagInstanceId, Guid loggedUserId, ERole userRole, bool isFinal)
+            {
                 Annotation annotation = null;
                 try
+                {
                     annotation = context.Annotations
                        .Where(a => a.Id == annotationId)
                        .Include(a => a.User)
                        .Include(a => a.Document).ThenInclude(d => d.Content)
                        .First();
                     if (!isFinal)
+                    {
                         annotation = context.Annotations
                         .Where(a => a.Id == annotationId)
                         .Include(a => a.User)
                         .Include(a => a.Document).ThenInclude(d => d.Content)
                         .First();
+                    }
                     else
+                    {
                         annotation = context.FinalAnnotations
                         .Where(a => a.Id == annotationId)
                         .Include(a => a.User)
                         .Include(a => a.Document).ThenInclude(d => d.Content)
                         .First();
+                    }
+                }
                 catch (Exception ex)
-...
+                    }
+                }
                 if (!context.AnnotationTags.Any(at => at.Id == tagInstanceId))
                 AnnotationTagGeneric annotationTag = new();
                 if (isFinal)
+                {
                     throw new InvalidOperationException("Could not find tag instance");
+                }
                     if (!context.FinalAnnotationTags.Any(at => at.Id == tagInstanceId))
+                    {
                         throw new InvalidOperationException("Could not find tag instance");
+                    }
                     annotationTag = context.FinalAnnotationTags.First(at => at.Id == tagInstanceId);
+                }
                 else
+                {
                     if (!context.AnnotationTags.Any(at => at.Id == tagInstanceId))
+                    {
                         throw new InvalidOperationException("Could not find tag instance");
+                    }
                     annotationTag = context.AnnotationTags.First(at => at.Id == tagInstanceId);
+                }
                 var annotationTag = context.AnnotationTags.First(at => at.Id == tagInstanceId);
                 annotation.LastModifiedTagId = annotationTag.Id;
                 annotation.ModifiedType = EModified.REMOVED;
                 context.AnnotationTags.Remove(annotationTag);
                 if (isFinal)
+                {
                     context.FinalAnnotationTags.Remove(annotationTag as FinalAnnotationTag);
+                }
                 else
+                {
                     context.AnnotationTags.Remove(annotationTag as AnnotationTag);
+                }
                 context.SaveChanges();
+            }
             public void SetTagInstanceSentiment(Guid annotationId, Guid instanceId, Guid userId, ERole userRole, ETagSentiment sentiment)
             public void SetTagInstanceSentiment(Guid annotationId, Guid instanceId, Guid userId, ERole userRole, ETagSentiment sentiment, bool isFinal)
+            {
                 Annotation annotation = null;
                 try
+                {
                     annotation = context.Annotations
                        .Where(a => a.Id == annotationId)
                        .Include(a => a.User)
                        .Include(a => a.Document).ThenInclude(d => d.Content)
                        .First();
                     if (!isFinal)
+                    {
                         annotation = context.Annotations
                         .Where(a => a.Id == annotationId)
                         .Include(a => a.User)
                         .Include(a => a.Document).ThenInclude(d => d.Content)
                         .First();
+                    }
                     else
+                    {
                         annotation = context.FinalAnnotations
                         .Where(a => a.Id == annotationId)
                         .Include(a => a.User)
                         .Include(a => a.Document).ThenInclude(d => d.Content)
                         .First();
+                    }
+                }
                 catch (Exception ex)
+                {
-...
+                }
                 var tagInstances = context.AnnotationTags.Where(at => at.Instance == instanceId).ToList();
                 IEnumerable<AnnotationTagGeneric> tagInstances = null;
                 if (isFinal)
+                {
                     tagInstances = context.FinalAnnotationTags.Where(at => at.Instance == instanceId).ToList();
+                }
                 else
+                {
                     tagInstances = context.AnnotationTags.Where(at => at.Instance == instanceId).ToList();
+                }
                 if (tagInstances.Count() == 0)
+                {
                     throw new InvalidOperationException("No such instance found");
-...
                 context.SaveChanges();
+            }
             public void MarkAnnotationAsDone(Guid annotationId, Guid userId, ERole userRole, bool done)
             public void MarkAnnotationAsDone(Guid annotationId, Guid userId, ERole userRole, bool done, bool isFinal)
+            {
                 Annotation annotation = null;
                 try
+                {
                     annotation = context.Annotations
                     if (!isFinal)
+                    {
                         annotation = context.Annotations
                        .Where(a => a.Id == annotationId)
                        .Include(a => a.User)
                        .Include(a => a.Document).ThenInclude(d => d.Content)
                        .First();
+                    }
                     else
+                    {
                         annotation = context.FinalAnnotations
                        .Where(a => a.Id == annotationId)
                        .Include(a => a.User)
                        .Include(a => a.Document).ThenInclude(d => d.Content)
                        .First();
+                    }
+                }
                 catch (Exception ex)
+                {
                     throw new InvalidOperationException("Could not find annotation");
+                }
                 if (userRole < ERole.ADMINISTRATOR)
+                {
                     if (annotation.User.Id != userId)

+        {
             public void CreateDocumentAnnotations(AnnotationsAddRequest request, Guid userId);
             public AnnotationListResponse GetUserAnnotations(Guid userId);
             public AnnotationInfo GetAnnotation(Guid annotationId, Guid userId, ERole userRole);
             public void AddAnnotationInstance(Guid annotationId, Guid userId, ERole userRole, AnnotationInstanceAddRequest request);
             public void DeleteAnnotationInstance(Guid annotationId, Guid tagInstanceId, Guid loggedUserId, ERole userRole);
             public void AddNoteToAnnotation(Guid annotationId, Guid userId, ERole userRole, AddNoteToAnnotationRequest request);
             public void SetTagInstanceSentiment(Guid annotationId, Guid instanceId, Guid userId, ERole userRole, ETagSentiment sentiment);
             public void MarkAnnotationAsDone(Guid annotationId, Guid userId, ERole userRole, bool done);
             public AnnotationInfo GetAnnotation(Guid annotationId, Guid userId, ERole userRole, bool isFinal);
             public void AddAnnotationInstance(Guid annotationId, Guid userId, ERole userRole, AnnotationInstanceAddRequest request, bool isFinal);
             public void DeleteAnnotationInstance(Guid annotationId, Guid tagInstanceId, Guid loggedUserId, ERole userRole, bool isFinal);
             public void AddNoteToAnnotation(Guid annotationId, Guid userId, ERole userRole, AddNoteToAnnotationRequest request, bool isFinal);
             public void SetTagInstanceSentiment(Guid annotationId, Guid instanceId, Guid userId, ERole userRole, ETagSentiment sentiment, bool isFinal);
             public void MarkAnnotationAsDone(Guid annotationId, Guid userId, ERole userRole, bool done, bool isFinal);
             public Guid CreateFinalAnnotation(Guid documentId, Guid userId);
+        }
+    }

Backend/Core/Services/TagService/ITagService.cs
22	22	public void CreateSubTag(CreateSubTagRequest request);
23	23	public void DeleteSubTag(Guid subtagId);
24	24	public void UpdateSubTag(ModifySubTagRequest request, Guid subtagId);
25		public void AddNoteToTagInstance(Guid annotationId, Guid occurrenceId, User user, AddNoteToTagOccurenceRequest request);
	25	public void AddNoteToTagInstance(Guid annotationId, Guid occurrenceId, User user, AddNoteToTagOccurenceRequest request, bool isFinal);
26	26	}
27	27	}

Backend/Core/Services/TagService/TagServiceEF.cs
38	38	var tags = databaseContext.Tags
39	39	.Select(tc => tc)
40	40	.ToList();
41
	41
42	42	var subTags = databaseContext.SubTags
43	43	.Select(tc => tc)
44	44	.ToList();
...	...
266	266
267	267	if (request.SentimentEnabled != null)
268	268	{
269		subtag.SentimentEnabled = (bool) request.SentimentEnabled;
	269	subtag.SentimentEnabled = (bool)request.SentimentEnabled;
270	270	}
271	271
272	272	databaseContext.SaveChanges();
273	273	}
274	274
275		public void AddNoteToTagInstance(Guid annotationId, Guid occurrenceId, User user, AddNoteToTagOccurenceRequest request)
	275	public void AddNoteToTagInstance(Guid annotationId, Guid occurrenceId, User user, AddNoteToTagOccurenceRequest request, bool isFinal)
276	276	{
277	277	Annotation annotation = null;
278	278	try
279	279	{
280		annotation = databaseContext.Annotations.Include(a => a.User).First(a => a.Id == annotationId);
	280	if (!isFinal)
	281	{
	282	annotation = databaseContext.Annotations.Include(a => a.User).First(a => a.Id == annotationId);
	283	}
	284	else
	285	{
	286	annotation = databaseContext.FinalAnnotations.Include(a => a.User).First(a => a.Id == annotationId);
	287	}
	288
281	289	}
282	290	catch (Exception)
283	291	{
...	...
289	297	throw new UnauthorizedAccessException("User does not have access to this annotation");
290	298	}
291	299
292		AnnotationTag occurence = null;
	300	AnnotationTagGeneric occurence = null;
293	301	try
294	302	{
295		occurence = databaseContext.AnnotationTags.Include(at => at.Annotation)
	303	if (!isFinal)
	304	{
	305	occurence = databaseContext.AnnotationTags.Include(at => at.Annotation)
296	306	.First(at => at.Annotation.Id == annotationId && at.Id == occurrenceId);
	307	}
	308	else
	309	{
	310	occurence = databaseContext.FinalAnnotationTags.Include(at => at.Annotation)
	311	.First(at => at.Annotation.Id == annotationId && at.Id == occurrenceId);
	312	}
297	313	}
298	314	catch (Exception)
299	315	{

Také k dispozici: Unified diff

Projekt

Obecné

Profil

ASWI - Pokročilé softwarové inženýrství » ASWI 2022 » Anotace pro analýzu smluvních podmínek a skrytých reklam (AV ČR) - 0x00

Revize 83d4581e

Přidáno uživatelem Vojtěch Bartička před téměř 3 roky(ů)