/// <summary>
        /// Gets the join table alias.
        /// </summary>
        /// <param name="joinField">The join field.</param>
        /// <returns>System.String.</returns>
        public string GetJoinTableAlias(ChecklistFieldDefinition joinField)
        {
            if (!_joinTableAliases.ContainsKey(joinField))
                _joinTableAliases[joinField] = "t" + _tableAliasIndex++;

            return _joinTableAliases[joinField];
        }
        /// <summary>
        /// Gets the reverse cross reference items query.
        /// </summary>
        /// <param name="join">The join.</param>
        /// <param name="referenceField">The reference field.</param>
        /// <param name="aliasCollection">The alias collection.</param>
        /// <returns>System.String.</returns>
        private string GetReverseCrossReferenceItemsQuery(
            ReverseCrossReferenceFieldDefinition join, ChecklistFieldDefinition referenceField, TableAliasCollection aliasCollection)
        {
            var result = new StringBuilder();

            result.AppendFormat(
                @"
{0}
AS
(
    SELECT q1.""{1}"", q2.""{2}"" AS ""{7}""
    FROM
        ""{3}"" q1
        INNER JOIN ""{4}"" q2 ON q2.""{5}"" = q1.""{1}""
    WHERE q1.""{6}"" = 0
)",
                aliasCollection.GetReverseCrossReferenceItemsQueryName(join),
                OracleNamesTranslator.Translate(Constants.IdColumnName),
                OracleNamesTranslator.Translate(GetJoinTableChildKey(referenceField)),
                OracleNamesTranslator.Translate(join.ReferencedProcess.SystemName),
                OracleNamesTranslator.Translate(GetJoinTableName(referenceField)),
                OracleNamesTranslator.Translate(GetJoinTableMasterKey(referenceField)),
                OracleNamesTranslator.Translate(Constants.IsRemovedColumnName),
                OracleNamesTranslator.Translate(referenceField.SystemName));

            return result.ToString();
        }
 /// <summary>
 /// Adds the checklist join.
 /// </summary>
 /// <param name="sql">The SQL.</param>
 /// <param name="join">The join.</param>
 /// <param name="aliasCollection">The alias collection.</param>
 private void AddChecklistJoin(StringBuilder sql, ChecklistFieldDefinition join, TableAliasCollection aliasCollection)
 {
     sql.AppendLine()
        .Append("\t")
        .AppendFormat(
            "INNER JOIN \"{0}\" {1} ON {1}.\"{2}\" = {3}.\"{4}\"",
            OracleNamesTranslator.Translate(GetJoinTableName(join)),
            aliasCollection.GetJoinTableAlias(join),
            OracleNamesTranslator.Translate(GetJoinTableMasterKey(join)),
            aliasCollection.GetTableAlias(join.DeclaringProcess),
            OracleNamesTranslator.Translate(Constants.IdColumnName))
        .AppendLine()
        .Append("\t")
        .AppendFormat(
            "INNER JOIN \"{0}\" {1} ON {1}.\"{2}\" = {3}.\"{4}\" AND {1}.\"{5}\" = 0",
            OracleNamesTranslator.Translate(join.ReferencedProcess.SystemName),
            aliasCollection.GetTableAlias(join.ReferencedProcess),
            OracleNamesTranslator.Translate(Constants.IdColumnName),
            aliasCollection.GetJoinTableAlias(join),
            OracleNamesTranslator.Translate(GetJoinTableChildKey(join)),
            OracleNamesTranslator.Translate(Constants.IsRemovedColumnName));
 }
 /// <summary>
 /// Gets the join table child key.
 /// </summary>
 /// <param name="join">The join.</param>
 /// <returns>System.String.</returns>
 protected virtual string GetJoinTableChildKey(ChecklistFieldDefinition join)
 {
     return join.ReferencedProcess.SystemName + "Id";
 }
 /// <summary>
 /// Gets the join table master key.
 /// </summary>
 /// <param name="join">The join.</param>
 /// <returns>System.String.</returns>
 protected virtual string GetJoinTableMasterKey(ChecklistFieldDefinition join)
 {
     return join.DeclaringProcess.SystemName + "Id";
 }
 /// <summary>
 /// Gets the name of the join table.
 /// </summary>
 /// <param name="join">The join.</param>
 /// <returns>System.String.</returns>
 protected virtual string GetJoinTableName(ChecklistFieldDefinition join)
 {
     return string.Format("{0}{1}_Answers", join.DeclaringProcess.SystemName, join.SystemName);
 }
Beispiel #7
0
        /// <summary>
        /// Creates the join.
        /// </summary>
        /// <param name="process">The process.</param>
        /// <param name="field">The field.</param>
        /// <returns>ReferenceFieldDefinition.</returns>
        /// <exception cref="System.InvalidOperationException">
        /// </exception>
        private ReferenceFieldDefinition CreateJoin(ProcessDefinition process, Process.FieldInfo field)
        {
            var declaringProcess = FindBaseProcess(process, field.DefinedIn);

            switch (field.ColumnType)
            {
                case ColumnTypes.Reference:
                    {
                        var fieldInfo = CrossRefFieldInfo.GetCrossRefFieldInfo(field.Id);
                        if (fieldInfo == null || fieldInfo.CrossRefProcessId == 0)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = GetPublishedProcessInfo(fieldInfo.CrossRefProcessId);
                        
                        var join = new SingleCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = CreateProcessDefinition(referencedProcess)
                                       };

                        return join;
                    }

                case ColumnTypes.MultiReference:
                    {
                        var fieldInfo = CrossRefFieldInfo.GetCrossRefFieldInfo(field.Id);
                        if (fieldInfo == null || fieldInfo.CrossRefProcessId == 0)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = CreateProcessDefinition(GetPublishedProcessInfo(fieldInfo.CrossRefProcessId));

                        var join = new MultiCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = referencedProcess
                                       };

                        if (!string.IsNullOrEmpty(fieldInfo.LinkFieldSystemName))
                            join.LinkField =
                                (SingleCrossReferenceFieldDefinition)CreateJoin(referencedProcess, fieldInfo.LinkFieldSystemName);

                        return join;
                    }

                case ColumnTypes.ReverseReference:
                    {
                        var fieldInfo = ReverseCrossRefFieldInfo.GetReverseCrossRefFieldInfo(field.Id);
                        if (fieldInfo == null || fieldInfo.ReferenceProcessId == 0)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = CreateProcessDefinition(GetPublishedProcessInfo(fieldInfo.ReferenceProcessId));
                        var join = new SingleReverseCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = referencedProcess,
                                           ReferenceField = CreateJoin(referencedProcess, fieldInfo.ReferenceField),
                                           ShowLatestVersion = fieldInfo.ShowLatestVersion
                                       };

                        return join;
                    }

                case ColumnTypes.ReverseMultiReference:
                    {
                        var fieldInfo = ReverseCrossRefFieldInfo.GetReverseCrossRefFieldInfo(field.Id);
                        if (fieldInfo == null || fieldInfo.ReferenceProcessId == 0)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = CreateProcessDefinition(GetPublishedProcessInfo(fieldInfo.ReferenceProcessId));
                        var join = new MultiReverseCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = referencedProcess,
                                           ReferenceField = CreateJoin(referencedProcess, fieldInfo.ReferenceField),
                                           ShowLatestVersion = fieldInfo.ShowLatestVersion
                                       };

                        return join;
                    }

                case ColumnTypes.Checklist:
                    {
                        var fieldInfo = ChecklistFieldInfo.GetChecklistFieldInfo(field.Id);
                        if (fieldInfo == null || fieldInfo.CrossRefProcessId == 0)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = GetPublishedProcessInfo(fieldInfo.CrossRefProcessId);
                        var join = new ChecklistFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = CreateProcessDefinition(referencedProcess)
                                       };

                        return join;
                    }
            }

            throw new InvalidOperationException(
                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));
        }
Beispiel #8
0
        /// <summary>
        /// Creates the join.
        /// </summary>
        /// <param name="process">The process.</param>
        /// <param name="field">The field.</param>
        /// <returns>ReferenceFieldDefinition.</returns>
        /// <exception cref="System.InvalidOperationException">
        /// </exception>
        private ReferenceFieldDefinition CreateJoin(ProcessDefinition process, FieldEdit field)
        {
            var declaringProcess = FindBaseProcess(process, field.GetBaseCopy().GetParent<IProcessEdit>().SystemName);

            switch (field.GetColumnType())
            {
                case ColumnTypes.Reference:
                    {
                        var step = field.StepList.OfType<CrossRefRequiredStepEdit>().FirstOrDefault();

                        if (step == null || !step.CrossRefProcessId.HasValue)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = GetPublishedProcessInfo(step.CrossRefProcessId.Value);
                        var join = new SingleCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = CreateProcessDefinition(referencedProcess)
                                       };

                        return join;
                    }

                case ColumnTypes.MultiReference:
                    {
                        var step = field.StepList.OfType<CrossRefRequiredStepEdit>().FirstOrDefault();

                        if (step == null || !step.CrossRefProcessId.HasValue)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = GetPublishedProcessInfo(step.CrossRefProcessId.Value);
                        var join = new MultiCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = CreateProcessDefinition(referencedProcess)
                                       };

                        if (!string.IsNullOrEmpty(step.LinkFieldSystemName))
                            join.LinkField =
                                (SingleCrossReferenceFieldDefinition)CreateJoin(join.ReferencedProcess, step.LinkFieldSystemName);

                        return join;
                    }

                case ColumnTypes.ReverseReference:
                    {
                        var step = field.StepList.OfType<ReverseCrossRefRequiredStepEdit>().FirstOrDefault();

                        if (step == null || !step.ReverseCrossRefProcessId.HasValue)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var optionsStep = field.StepList.OfType<ReverseCrossRefOptionsStepEdit>().FirstOrDefault();
                        var referencedProcess = CreateProcessDefinition(GetPublishedProcessInfo(step.ReverseCrossRefProcessId.Value));
                        var join = new SingleReverseCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = referencedProcess,
                                           ReferenceField = CreateJoin(referencedProcess, step.CrossRefFieldName),
                                           ShowLatestVersion = optionsStep != null && optionsStep.ShowLatestVersion
                                       };

                        return join;
                    }

                case ColumnTypes.ReverseMultiReference:
                    {
                        var step = field.StepList.OfType<ReverseCrossRefRequiredStepEdit>().FirstOrDefault();

                        if (step == null || !step.ReverseCrossRefProcessId.HasValue)
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var optionsStep = field.StepList.OfType<ReverseCrossRefOptionsStepEdit>().FirstOrDefault();
                        var referencedProcess = CreateProcessDefinition(GetPublishedProcessInfo(step.ReverseCrossRefProcessId.Value));
                        var join = new MultiReverseCrossReferenceFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = referencedProcess,
                                           ReferenceField = CreateJoin(referencedProcess, step.CrossRefFieldName),
                                           ShowLatestVersion = optionsStep != null && optionsStep.ShowLatestVersion
                                       };

                        return join;
                    }

                case ColumnTypes.Checklist:
                    {
                        var step = field.StepList.OfType<ChecklistSettingsStepEdit>().FirstOrDefault();

                        if (step == null || string.IsNullOrEmpty(step.AnswerProcessSystemName))
                            throw new InvalidOperationException(
                                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));

                        var referencedProcess = GetPublishedProcessInfo(step.AnswerProcessSystemName);

                        var join = new ChecklistFieldDefinition
                                       {
                                           SystemName = field.SystemName,
                                           DeclaringProcess = declaringProcess,
                                           ReferencedProcess = CreateProcessDefinition(referencedProcess)
                                       };

                        return join;
                    }
            }

            throw new InvalidOperationException(
                string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a valid reference field.", field.SystemName));
        }
        private string GetReverseCrossReferenceItemsQuery(
            ReverseCrossReferenceFieldDefinition join, ChecklistFieldDefinition referenceField, TableAliasCollection aliasCollection)
        {
            var result = new StringBuilder();

            result.AppendFormat(
                @"
{0}
AS
(
    SELECT q1.[{1}], q2.[{2}] AS [{7}]
    FROM
        [dbo].[{3}] q1
        INNER JOIN [dbo].[{4}] q2 ON q2.[{5}] = q1.[{1}]
    WHERE q1.[{6}] = 0
)",
                aliasCollection.GetReverseCrossReferenceItemsQueryName(join),
                Constants.IdColumnName,
                GetJoinTableChildKey(referenceField),
                join.ReferencedProcess.SystemName,
                GetJoinTableName(referenceField),
                GetJoinTableMasterKey(referenceField),
                Constants.IsRemovedColumnName,
                referenceField.SystemName);

            return result.ToString();
        }
 private void AddChecklistJoin(StringBuilder sql, ChecklistFieldDefinition join, TableAliasCollection aliasCollection)
 {
     sql.AppendLine()
        .Append("\t")
        .AppendFormat(
            "INNER JOIN [dbo].[{0}] {1} ON {1}.[{2}] = {3}.[{4}]",
            GetJoinTableName(join),
            aliasCollection.GetJoinTableAlias(join),
            GetJoinTableMasterKey(join),
            aliasCollection.GetTableAlias(join.DeclaringProcess),
            Constants.IdColumnName)
        .AppendLine()
        .Append("\t")
        .AppendFormat(
            "INNER JOIN [dbo].[{0}] {1} ON {1}.[{2}] = {3}.[{4}] AND {1}.[{5}] = 0",
            join.ReferencedProcess.SystemName,
            aliasCollection.GetTableAlias(join.ReferencedProcess),
            Constants.IdColumnName,
            aliasCollection.GetJoinTableAlias(join),
            GetJoinTableChildKey(join),
            Constants.IsRemovedColumnName);
 }