private void ValidateGroup()

in FixAntenna/NetCore/Validation/Validators/GroupValidator.cs [156:350]
169 lines of code
27 McCabe index (conditional complexity)

		private void ValidateGroup(IList<ValidationFixGroup> validationFixGroups, ValidationFixMessage fixMessage,
			string msgType, FixErrorContainer errors)
		{
			// // gets all tags of group
			// final Map<Integer, Field> groupTags = util.getGroupTagsWithInternalGroups(msgType, tag, fixMessage);

			foreach (var validationFixGroup in validationFixGroups)
			{
				// gets internal groups for the parent group
				var internalFixGroups = validationFixGroup.ValidationFixGroups;
				// check to the parent group Contains the child groups.
				if (internalFixGroups != null && internalFixGroups.Count > 0)
				{
					ValidateGroup(internalFixGroups, fixMessage, msgType, errors);
				}

				var noField = validationFixGroup.GetNoField();
				FixGroupContainer container;
				try
				{
					container = FixGroupContainer.CreateFixGroupContainer(fixMessage, Util)
						.CreateSeparateList(fixMessage, validationFixGroup.FixMessage, noField);
				}
				catch (FormatException e)
				{
					errors.Add(FixErrorBuilder.BuildError(FixErrorCode.Other, (TagValue)null,
						"The message: " + fixMessage.GetMsgType() +
						" is not valid because : throw NumberFormatException " + e.Message));
					return;
				}
				catch (ArgumentException e)
				{
					errors.Add(FixErrorBuilder.BuildError(FixErrorCode.Other, (TagValue)null,
						"The message: " + fixMessage.GetMsgType() +
						" is not valid because : throw IllegalArgumentException " + e.Message));
					return;
				}

				// isRequired group.
				var messages = container.GetFixMessages();
				var startField = Util.GetStartTagForGroup(msgType, noField);
				if (messages.Count != container.GetGroupsCount())
				{
					errors.Add(FixErrorBuilder.BuildError(
						FixErrorCode.IncorrectNumingroupCountForRepeatingGroup, fixMessage.GetTag(startField),
						fixMessage.GetMsgSeqNumber(), msgType, startField));
				}

				foreach (var contentOfGroup in messages)
				{
					// check start field of group.
					var fieldsCount = contentOfGroup.Length;
					for (var fieldIndex = 0; fieldIndex < fieldsCount; fieldIndex++)
					{
						var field = contentOfGroup[fieldIndex];
						if (field.TagId == noField)
						{
							var nextFieldIndex = fieldIndex + 1;
							if (nextFieldIndex < fieldsCount)
							{
								if (contentOfGroup[nextFieldIndex].TagId != startField)
								{
									errors.Add(FixErrorBuilder.BuildError(
										FixErrorCode.RepeatingGroupFieldsOutOfOrder, fixMessage.GetTag(startField),
										fixMessage.GetMsgSeqNumber(), msgType, startField));
								}
							}

							break;
						}
					}

					// checks order of groups tag.
					CheckOrderOfGroupsTag(validationFixGroup.FixMessage, fixMessage.FullFixMessage,
						noField, errors, msgType, startField);

					var countOfRepeatingGroups = 0;
					try
					{
						// gets max of frequency of tags
						countOfRepeatingGroups = (int)contentOfGroup.GetTagValueAsLong(noField);
					}
					catch (FormatException e)
					{
						errors.Add(FixErrorBuilder.BuildError(FixErrorCode.Other, (TagValue)null,
							"The message: " + fixMessage.GetMsgType() +
							" is not valid because : throw NumberFormatException " + e.Message));
						return;
					}
					catch (ArgumentException e)
					{
						errors.Add(FixErrorBuilder.BuildError(FixErrorCode.Other, (TagValue)null,
							"The message: " + fixMessage.GetMsgType() +
							" is not valid because : throw IllegalArgumentException " + e.Message));
						return;
					}
					catch (FieldNotFoundException e)
					{
						errors.Add(FixErrorBuilder.BuildError(FixErrorCode.Other, (TagValue)null,
							"The message: " + fixMessage.GetMsgType() +
							" is not valid because : throw FieldNotFoundException " + e.Message));
						return;
					}

					IList<Field> requiredFieldsOfGroup = new List<Field>();
					if (fieldsCount > 0)
					{
						requiredFieldsOfGroup =
							GetRequiredFields(Util.GetGroupsTags(msgType, noField, contentOfGroup, false));
					}

					var groupTags =
						Util.GetGroupTagsWithInternalGroups(msgType, noField, fixMessage.FullFixMessage);
					for (var index = 0; index < fieldsCount; index++)
					{
						var fixField = contentOfGroup[index];
						groupTags.TryGetValue(fixField.TagId, out var groupTag);
						if (groupTag != null)
						{
							requiredFieldsOfGroup.Remove(groupTag);
							var groupTagValue = groupTag.Tag;
							var frequency = CountFrequency(contentOfGroup, groupTagValue);
							if (frequency == 0)
							{
								continue;
							}

							// checks first tag of group this tag must be always
							if (index == 0)
							{
								if ("Y".Equals(groupTag.Req))
								{
									if (contentOfGroup[1].TagId != groupTag.Tag)
									{
										errors.Add(FixErrorBuilder.BuildError(
											FixErrorCode.RepeatingGroupFieldsOutOfOrder,
											fixMessage.GetTag(groupTagValue), fixMessage.GetMsgSeqNumber(), msgType,
											groupTagValue));
									}
								}
								else
								{
									if (IsConditionalValidareFailed(errors, groupTag.Condreq))
									{
										errors.Add(FixErrorBuilder.BuildError(
											FixErrorCode.RepeatingGroupFieldsOutOfOrder,
											fixMessage.GetTag(groupTagValue), fixMessage.GetMsgSeqNumber(), msgType,
											groupTagValue));
									}
								}

								frequency = CountFrequency(validationFixGroup.FixMessage, groupTagValue);
								// checks first required tag
								CheckTag(msgType, errors, countOfRepeatingGroups, frequency,
									fixMessage.GetMsgSeqNumber(), fixMessage.GetTag(groupTagValue));
							}
							else
							{
								// checks required tag
								if ("Y".Equals(groupTag.Req))
								{
									frequency = CountFrequency(validationFixGroup.FixMessage, groupTagValue);
									CheckTag(msgType, errors, countOfRepeatingGroups, frequency,
										fixMessage.GetMsgSeqNumber(), fixMessage.GetTag(groupTagValue));
								}
								// check other tags of group
								else
								{
									// check if tag is present in group and counts of present(check only more than size of
									// repeating gorup because these not required tags. )
									frequency = CountFrequency(contentOfGroup, groupTagValue);
									if (frequency > 1)
									{
										errors.Add(FixErrorBuilder.BuildError(
											FixErrorCode.IncorrectNumingroupCountForRepeatingGroup,
											fixMessage.GetTag(groupTagValue), fixMessage.GetMsgSeqNumber(), msgType,
											groupTagValue));
									}
								}
							}
						}
					}

					if (requiredFieldsOfGroup.Count > 0)
					{
						foreach (var field in requiredFieldsOfGroup)
						{
							errors.Add(FixErrorBuilder.BuildError(FixErrorCode.RequiredTagMissing,
								new TagValue(field.Tag, ""), fixMessage.GetMsgSeqNumber(), msgType,
								field.Tag));
						}
					}
				}
			}
		}