Exemplo n.º 1
0
        public void Execute_TableValueInsertForFields_DoesNotThrowException()
        {
            var internalId = new Field
            {
                Name        = "INS_Internal ID",
                Description = "Unique ID used internally"
            };

            var firstName = new Field
            {
                Name        = "INS_First Name",
                Description = "The person's first name"
            };

            var lastName = new Field
            {
                Name        = "INS_Last Name",
                Description = "The person's last name"
            };

            var yearlyWage = new Field
            {
                Name        = "INS_Yearly Wage",
                Description = "The base wage paid year over year."
            };

            var hireDate = new Field
            {
                Name        = "INS_Hire Date",
                Description = "The date and time of hire for the person"
            };

            var bonusTarget = new Field
            {
                Name        = "INS_Bonus Target",
                Description = "The target bonus for the person"
            };

            var contactNumbers = new Field
            {
                Name        = "INS_Contact Numbers",
                Description = "A list of contact numbers for the person in order of preference"
            };

            var fields = new List <Field>
            {
                internalId,
                firstName,
                lastName,
                yearlyWage,
                hireDate,
                bonusTarget,
                contactNumbers
            };

            var providerFactory = new SqlClientProviderFactory(new DataAnnotationsDefinitionProvider());

            using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
            {
                var transaction = provider.BeginTransaction();

                var fieldRepository      = new EntityRepository <Field, FieldRow>(provider, this.mapper);
                var fieldValueRepository = new EntityRepository <FieldValue, FieldValueRow>(provider, this.mapper);

                // Delete the existing rows.
                var fieldSelection = Query.Select <FieldRow>().Where(set => set.AreEqual(row => row.Name, "INS_%"));
                var existingFields = fieldRepository.SelectEntities(fieldSelection);

                fieldValueRepository.DeleteSelection(
                    Query.Select <FieldValueRow>()
                    .Where(set => set.Include(row => row.FieldId, existingFields.Select(field => field.FieldId).ToArray())));

                fieldRepository.DeleteSelection(fieldSelection);
                var fieldInsertCommand = new TableValuedInsert <FieldRow>(provider.DatabaseContext);

                fieldInsertCommand.Execute(
                    fields.Select(
                        field => new FieldTableTypeRow
                {
                    Name        = field.Name,
                    Description = field.Description
                }));

                transaction.Commit();
            }
        }
Exemplo n.º 2
0
        public async Task ExecuteWithIdentityUpdateAsync_TableValuedInsertForGenericSubmission_DoesNotThrowException()
        {
            var providerFactory   = new SqlClientProviderFactory(new DataAnnotationsDefinitionProvider());
            var cancellationToken = CancellationToken.None;

            await using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
            {
                var identityRepository = new EntityRepository <DomainIdentity, DomainIdentityRow>(provider, this.mapper);

                var domainIdentity = await identityRepository.FirstOrDefaultAsync(
                    Query.Select <DomainIdentity>()
                    .Where(set => set.AreEqual(identity => identity.UniqueIdentifier, Environment.UserName)),
                    cancellationToken)
                                     .ConfigureAwait(false)
                                     ?? await identityRepository.SaveAsync(
                    new DomainIdentity(Environment.UserName)
                {
                    FirstName  = "King",
                    MiddleName = "T.",
                    LastName   = "Animal"
                },
                    cancellationToken)
                                     .ConfigureAwait(false);

                var expected   = new GenericSubmission("My Submission", domainIdentity);
                var internalId = new Field
                {
                    Name        = "Internal ID",
                    Description = "Unique ID used internally"
                };

                var firstName = new Field
                {
                    Name        = "First Name",
                    Description = "The person's first name"
                };

                var lastName = new Field
                {
                    Name        = "Last Name",
                    Description = "The person's last name"
                };

                var yearlyWage = new Field
                {
                    Name        = "Yearly Wage",
                    Description = "The base wage paid year over year."
                };

                var hireDate = new Field
                {
                    Name        = "Hire Date",
                    Description = "The date and time of hire for the person"
                };

                var bonusTarget = new Field
                {
                    Name        = "Bonus Target",
                    Description = "The target bonus for the person"
                };

                var contactNumbers = new Field
                {
                    Name        = "Contact Numbers",
                    Description = "A list of contact numbers for the person in order of preference"
                };

                expected.SetValue(internalId, 9234);
                expected.SetValue(firstName, "Dan");
                expected.SetValue(lastName, "The Man");
                expected.SetValue(yearlyWage, 75100.35m);
                expected.SetValue(hireDate, DateTimeOffset.Now);
                expected.SetValue(bonusTarget, 1.59834578934);
                expected.SetValue(
                    contactNumbers,
                    new List <string>
                {
                    "423-222-2252",
                    "615-982-0012",
                    "+1-555-252-5521"
                });

                expected.Submit();

                var fieldRepository = new EntityRepository <Field, FieldRow>(provider, this.mapper);

                // TODO: Return names only from the repo as a dynamic
                var fields          = expected.SubmissionValues.Select(value => value.Field).Distinct().ToDictionary(field => field.Name, field => field);
                var inclusionValues = fields.Keys.ToArray();
                var existingFields  = new List <Field>();

                await foreach (var item in fieldRepository.SelectEntitiesAsync(
                                   new EntitySelection <Field>().Where(set => set.Include(field => field.Name, inclusionValues)),
                                   cancellationToken)
                               .ConfigureAwait(false))
                {
                    existingFields.Add(item);
                }

                foreach (var field in existingFields)
                {
                    var output = fields[field.Name];
                    this.mapper.MapTo(field, output);
                }

                foreach (var field in fields.Values.Where(field => field.FieldId.HasValue == false))
                {
                    await fieldRepository.SaveAsync(field, cancellationToken).ConfigureAwait(false);
                }

                var submissionRepository = new EntityRepository <GenericSubmission, GenericSubmissionRow>(provider, this.mapper);

                var transaction = await provider.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);

                await submissionRepository.SaveAsync(expected, cancellationToken).ConfigureAwait(false);

                var submissionId = expected.GenericSubmissionId.GetValueOrDefault();
                Assert.AreNotEqual(0, submissionId);

                // Do the field values
                var valuesList = from v in expected.SubmissionValues
                                 select new FieldValueTableTypeRow
                {
                    FieldId = v.Field.FieldId.GetValueOrDefault(),
                    LastModifiedByDomainIdentifierId = domainIdentity.DomainIdentityId.GetValueOrDefault(),
                    LastModifiedTime = expected.SubmittedTime
                };

                var valuesCommand  = new TableValuedInsert <FieldValueRow>(provider.DatabaseContext).SelectFromInserted();
                var insertedValues = new List <FieldValueRow>();

                await foreach (var item in valuesCommand.ExecuteForResultsAsync(valuesList, cancellationToken).ConfigureAwait(false))
                {
                    insertedValues.Add(item);
                }

                // Map back to the domain object.
                foreach (var value in expected.SubmissionValues)
                {
                    var input = insertedValues.FirstOrDefault(row => row.FieldId == value.Field.FieldId);
                    this.mapper.MapTo(input, value);
                }

                // Do the field value elements
                var elementsList = (from e in expected.SubmissionValues.SelectMany(value => value.Elements)
                                    select new FieldValueElementTableTypeRow
                {
                    FieldValueElementId = e.FieldValueElementId,
                    FieldValueId = e.FieldValue.FieldValueId.GetValueOrDefault(),
                    Order = e.Order,
                    DateElement = e.Element as DateTimeOffset? ?? e.Element as DateTime?,
                    FloatElement = e.Element as double? ?? e.Element as float?,
                    IntegerElement = e.Element as long? ?? e.Element as int? ?? e.Element as short? ?? e.Element as byte?,
                    MoneyElement = e.Element as decimal?,
                    TextElement = e.Element as string                            // here we actually want it to be null if it is not a string
                }).ToList();

                var elementsCommand = new TableValuedInsert <FieldValueElementRow>(provider.DatabaseContext).SelectFromInserted();

                // Reassign with our added identities
                // TODO: create dictionary for seeks
                var insertedElementRows = new List <FieldValueElementRow>();

                await foreach (var item in elementsCommand.ExecuteForResultsAsync(elementsList, cancellationToken).ConfigureAwait(false))
                {
                    insertedElementRows.Add(item);
                }

                foreach (var element in elementsList)
                {
                    var input = insertedElementRows.First(row => row.FieldValueId == element.FieldValueId && row.Order == element.Order);
                    this.mapper.MapTo(input, element);
                }

                var dateElementsCommand = new TableValuedInsert <DateElementRow>(provider.DatabaseContext)
                                          .InsertInto(row => row.DateElementId, row => row.Value)
                                          .From <FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.DateElement);

                await dateElementsCommand.ExecuteAsync(elementsList.Where(row => row.DateElement.HasValue), cancellationToken).ConfigureAwait(false);

                var floatElementsCommand = new TableValuedInsert <FloatElementRow>(provider.DatabaseContext)
                                           .InsertInto(row => row.FloatElementId, row => row.Value)
                                           .From <FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.FloatElement);

                await floatElementsCommand.ExecuteAsync(elementsList.Where(row => row.FloatElement.HasValue), cancellationToken)
                .ConfigureAwait(false);

                var integerElementsCommand = new TableValuedInsert <IntegerElementRow>(provider.DatabaseContext)
                                             .InsertInto(row => row.IntegerElementId, row => row.Value)
                                             .From <FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.IntegerElement);

                await integerElementsCommand.ExecuteAsync(elementsList.Where(row => row.IntegerElement.HasValue), cancellationToken)
                .ConfigureAwait(false);

                var moneyElementsCommand = new TableValuedInsert <MoneyElementRow>(provider.DatabaseContext)
                                           .InsertInto(row => row.MoneyElementId, row => row.Value)
                                           .From <FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.MoneyElement);

                await moneyElementsCommand.ExecuteAsync(elementsList.Where(row => row.MoneyElement.HasValue), cancellationToken)
                .ConfigureAwait(false);

                var textElementsCommand = new TableValuedInsert <TextElementRow>(provider.DatabaseContext)
                                          .InsertInto(row => row.TextElementId, row => row.Value)
                                          .From <FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.TextElement);

                await textElementsCommand.ExecuteAsync(elementsList.Where(row => row.TextElement != null), cancellationToken).ConfigureAwait(false);

                // Attach the values to the submission
                var genericValueSubmissions = from v in insertedValues
                                              select new GenericSubmissionValueTableTypeRow
                {
                    GenericSubmissionId      = submissionId,
                    GenericSubmissionValueId = v.FieldValueId
                };

                var submissionCommand = new TableValuedInsert <GenericSubmissionValueTableTypeRow>(provider.DatabaseContext);
                await submissionCommand.ExecuteAsync(genericValueSubmissions, cancellationToken).ConfigureAwait(false);

                await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
            }
        }