public static void BulkUpdate(DbConnection con, List<AttributeDefinition> models)
        {
            StringBuilder queryBuilder = new StringBuilder();
            string updateAttributeDefinitionQuery = @"
                UPDATE AttributeDefinitions
                SET IsIdentifier = @IsIdentifier,
                IsAutoEncoding = @IsAutoEncoding,
                IsDecision = @IsDecision,
                AttributeDataType = @AttributeDataType,
                Description = @Description,
                ValidationStatus = @ValidationStatus
                WHERE Id = @Id;
            ";

            string deleteMapRuleQuery = @"
                DELETE FROM MapRules WHERE AttributeDefinitionId = @AttributeDefinitionId;
            ";

            string insertMapRuleQuery = @"
                INSERT INTO MapRules(AttributeDefinitionId, RuleContent, RuleType) VALUES(@AttributeDefinitionId, @RuleContent, @RuleType);
            ";

            con.Execute(updateAttributeDefinitionQuery, models);
            var mapRuleModels = new List<MapRule>();
            models.ForEach(p => {
                mapRuleModels.AddRange(p.MapRules);
            });

            if (mapRuleModels.Count > 0)
            {
                con.Execute(deleteMapRuleQuery, mapRuleModels);
                con.Execute(insertMapRuleQuery, mapRuleModels);
            }
        }
예제 #2
0
 public void CheckDbAccess(string connectionstring)
 {
     using (_connection = Utilities.GetOpenConnection(connectionstring))
     {
         _connection.Execute("CREATE TABLE testdb (Id int)");
         _connection.Execute("DROP TABLE testdb");
     }
 }
 public static void BulkInsert(DbConnection con, List<AttributeDefinition> models)
 {
     con.Execute(@"
         INSERT INTO AttributeDefinitions(name, rawName, dataFileId, attributeIndex)
         VALUES(@Name,@RawName, @DataFileId, @AttributeIndex);
     ", models);
 }
예제 #4
0
    public int Insert(IDbConnection connection, IDbTransaction transaction, int?commandTimeout, string tableName, string columnList, string parameterList, IEnumerable <PropertyInfo> keyProperties, object entityToInsert)
    {
        var cmd = $"insert into {tableName} ({columnList}) values ({parameterList})";

        connection.Execute(cmd, entityToInsert, transaction, commandTimeout);
        var r = connection.Query("Select LAST_INSERT_ID() id", transaction: transaction, commandTimeout: commandTimeout);

        var id = r.First().id;

        if (id == null)
        {
            return(0);
        }
        var propertyInfos = keyProperties as PropertyInfo[] ?? keyProperties.ToArray();

        if (!propertyInfos.Any())
        {
            return(Convert.ToInt32(id));
        }

        var idp = propertyInfos.First();

        idp.SetValue(entityToInsert, Convert.ChangeType(id, idp.PropertyType), null);

        return(Convert.ToInt32(id));
    }
예제 #5
0
        public void GenerateInitialDatabase(string connectionstring)
        {
            //if database has versioninfo table ABORT
            using (_connection = Utilities.GetOpenConnection(connectionstring))
            {
                if (_connection.Query<string>("SELECT table_name FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'dbo' AND  TABLE_NAME = 'dbversions'").Any())
                    throw new Exception("What are you doing? The database already exists!");
            }
            //Regular expression that finds multiline block comments.
            Regex findComments = new Regex(@"\/\*.*?\*\/", RegexOptions.Singleline | RegexOptions.Compiled);

            using (_connection = Utilities.GetOpenConnection(connectionstring))
            {
                var statements = Lunch.Data.Install.SQLresources._0001_InitialLoad;
                if (string.IsNullOrEmpty(statements))
                {
                    throw new Exception("The sql statement to execute is empty.");
                }

                string sqlBatch = string.Empty;
                foreach (string line in statements.Split(new string[2] {"\n", "\r"}, StringSplitOptions.RemoveEmptyEntries))
                {
                    if (line.ToUpperInvariant().Trim() == "GO")
                    {
                        _connection.Execute(sqlBatch);
                        sqlBatch = string.Empty;
                    }
                    else
                    {
                        sqlBatch += line + "\n";
                    }
                }

            }
        }
 public RestaurantRating Delete(RestaurantRating entity)
 {
     using (_connection = Utilities.GetProfiledOpenConnection())
     {
         _connection.Execute("Delete from RestaurantRatings where UserID = @UserID and RestaurantID = @RestaurantID", entity);
     }
     return entity;
 }
예제 #7
0
 public int Insert(SearchHistoryLog entity)
 {
     using (_connection = Utilities.Database.GetProfiledOpenConnection())
     {
         const string query = "INSERT INTO SearchHistoryLogs (SearchId, SearchDate, LastTweetId, TweetCount) VALUES (@SearchId, @SearchDate, @LastTweetId,@TweetCount)";
         return _connection.Execute(query, entity);
     }
 }
예제 #8
0
 public void Delete(long id)
 {
     using (_connection = Utilities.Database.GetProfiledOpenConnection())
     {
         const string query = "DELETE FROM Searches WHERE SearchId = @SearchId";
         _connection.Execute(query, new { SearchId = id });
     }
 }
예제 #9
0
 public int Insert(IgnoreWord item)
 {
     using (_connection = Utilities.Database.GetProfiledOpenConnection())
     {
         const string query = "INSERT INTO IgnoreWords (IgnoreWordId, WordText) VALUES (@IgnoreWordId, @WordText)";
         return _connection.Execute(query, item);
     }
 }
        public static void Install(DbConnection connection, string schema)
        {
            if (connection == null) throw new ArgumentNullException(nameof(connection));

            Log.Info("Start installing Hangfire SQL objects...");

            if (!IsSqlEditionSupported(connection))
            {
                throw new PlatformNotSupportedException("The SQL Server edition of the target server is unsupported, e.g. SQL Azure.");
            }

            var script = GetStringResource(
                typeof(SqlServerObjectsInstaller).GetTypeInfo().Assembly, 
                "Hangfire.SqlServer.Install.sql");

            script = script.Replace("SET @TARGET_SCHEMA_VERSION = 5;", "SET @TARGET_SCHEMA_VERSION = " + RequiredSchemaVersion + ";");

            script = script.Replace("$(HangFireSchema)", !string.IsNullOrWhiteSpace(schema) ? schema : Constants.DefaultSchema);

#if NETFULL
            for (var i = 0; i < RetryAttempts; i++)
            {
                try
                {
                    connection.Execute(script);
                    break;
                }
                catch (DbException ex)
                {
                    if (ex.ErrorCode == 1205)
                    {
                        Log.WarnException("Deadlock occurred during automatic migration execution. Retrying...", ex);
                    }
                    else
                    {
                        throw;
                    }
                }
            }
#else
            connection.Execute(script);
#endif

            Log.Info("Hangfire SQL objects installed.");
        }
예제 #11
0
        public static void BulkUpdate(DbConnection con, List<DataFile> models)
        {
            StringBuilder queryBuilder = new StringBuilder();
            string updateDataFileQuery = @"
                UPDATE DataFiles
                SET Description = @Description
                WHERE Id = @Id;
            ";

            con.Execute(updateDataFileQuery, models);
        }
 public static int Add(CySequenceCounterEntity entity, DbConnection conn)
 {
     const string sql = @"INSERT INTO [dbo].[CySequenceCounter]
                         ([SequenceKey]
                         ,[CounterId]
                         ,UpdateTime)
                         VALUES
                         (@SequenceKey
                         ,@CounterId
                         ,@UpdateTime)";
     try
     {
         int result = conn.Execute(sql, entity);
         return result;
     }
     catch (Exception ex)
     {
         throw ;
     }
 }
예제 #13
0
 public void DropTableIfExists(DbConnection db, TableName table)
 {
     var name = _utils.EscapeTableName(table);
     db.Execute($"IF OBJECT_ID('{name}', 'U') IS NOT NULL DROP TABLE {name}");
 }
예제 #14
0
        private void SaveTimings(List<Timing> timings, DbConnection conn)
        {
            const string sql = @"INSERT INTO MiniProfilerTimings
            (Id,
             MiniProfilerId,
             ParentTimingId,
             Name,
             DurationMilliseconds,
             StartMilliseconds,
             IsRoot,
             Depth,
             CustomTimingsJson)
            SELECT       @Id,
             @MiniProfilerId,
             @ParentTimingId,
             @Name,
             @DurationMilliseconds,
             @StartMilliseconds,
             @IsRoot,
             @Depth,
             @CustomTimingsJson
            WHERE NOT EXISTS (SELECT 1 FROM MiniProfilerTimings WHERE Id = @Id)";

            foreach (var timing in timings)
            {
                conn.Execute(
                    sql,
                    new
                        {
                            timing.Id,
                            timing.MiniProfilerId,
                            timing.ParentTimingId,
                            Name = timing.Name.Truncate(200),
                            timing.DurationMilliseconds,
                            timing.StartMilliseconds,
                            timing.IsRoot,
                            timing.Depth,
                            timing.CustomTimingsJson
                        });
            }
        }
예제 #15
0
        private void SaveClientTimings(List<ClientTimings.ClientTiming> timings, DbConnection conn)
        {
            const string sql = @"INSERT INTO MiniProfilerClientTimings
            ( Id,
              MiniProfilerId,
              Name,
              Start,
              Duration)
            SELECT       @Id,
             @MiniProfilerId,
             @Name,
             @Start,
             @Duration
            WHERE NOT EXISTS (SELECT 1 FROM MiniProfilerClientTimings WHERE Id = @Id)";

            foreach (var timing in timings)
            {
                conn.Execute(
                    sql,
                    new
                    {
                        timing.Id,
                        timing.MiniProfilerId,
                        Name = timing.Name.Truncate(200),
                        timing.Start,
                        timing.Duration
                    });
            }
        }
예제 #16
0
 private static void InitTablesData( DbConnection connection )
 {
     connection.Execute( @"INSERT INTO [test_table] (Id, name) VALUES (1, 'Grinka')" );
     connection.Execute( @"INSERT INTO [test_table] (Id, name) VALUES (2, 'Lenk')" );
     connection.Execute( @"INSERT INTO [test_table] (Id, name) VALUES (3, 'Gina')" );
 }
        /// <summary>
        /// Saves parameter Timing to the dbo.MiniProfilerTimings table.
        /// </summary>
        protected virtual void SaveTiming(DbConnection conn, MiniProfiler profiler, Timing t)
        {
            const string sql =
            @"insert into MiniProfilerTimings
            (Id,
             MiniProfilerId,
             ParentTimingId,
             Name,
             Depth,
             StartMilliseconds,
             DurationMilliseconds,
             DurationWithoutChildrenMilliseconds,
             SqlTimingsDurationMilliseconds,
             IsRoot,
             HasChildren,
             IsTrivial,
             HasSqlTimings,
             HasDuplicateSqlTimings,
             ExecutedReaders,
             ExecutedScalars,
             ExecutedNonQueries)
            values      (@Id,
             @MiniProfilerId,
             @ParentTimingId,
             @Name,
             @Depth,
             @StartMilliseconds,
             @DurationMilliseconds,
             @DurationWithoutChildrenMilliseconds,
             @SqlTimingsDurationMilliseconds,
             @IsRoot,
             @HasChildren,
             @IsTrivial,
             @HasSqlTimings,
             @HasDuplicateSqlTimings,
             @ExecutedReaders,
             @ExecutedScalars,
             @ExecutedNonQueries)";

            conn.Execute(sql, new
            {
                Id = t.Id,
                MiniProfilerId = profiler.Id,
                ParentTimingId = t.IsRoot ? (Guid?)null : t.ParentTiming.Id,
                Name = t.Name.Truncate(200),
                Depth = t.Depth,
                StartMilliseconds = t.StartMilliseconds,
                DurationMilliseconds = t.DurationMilliseconds,
                DurationWithoutChildrenMilliseconds = t.DurationWithoutChildrenMilliseconds,
                SqlTimingsDurationMilliseconds = t.SqlTimingsDurationMilliseconds,
                IsRoot = t.IsRoot,
                HasChildren = t.HasChildren,
                IsTrivial = t.IsTrivial,
                HasSqlTimings = t.HasSqlTimings,
                HasDuplicateSqlTimings = t.HasDuplicateSqlTimings,
                ExecutedReaders = t.ExecutedReaders,
                ExecutedScalars = t.ExecutedScalars,
                ExecutedNonQueries = t.ExecutedNonQueries
            });

            if (t.HasSqlTimings)
            {
                foreach (var st in t.SqlTimings)
                {
                    SaveSqlTiming(conn, profiler, st);
                }
            }

            if (t.HasChildren)
            {
                foreach (var child in t.Children)
                {
                    SaveTiming(conn, profiler, child);
                }
            }
        }
        /// <summary>
        /// Saves any SqlTimingParameters used in the profiled SqlTiming to the dbo.MiniProfilerSqlTimingParameters table.
        /// </summary>
        protected virtual void SaveSqlTimingParameters(DbConnection conn, MiniProfiler profiler, SqlTiming st)
        {
            const string sql =
            @"insert into MiniProfilerSqlTimingParameters
            (MiniProfilerId,
             ParentSqlTimingId,
             Name,
             DbType,
             Size,
             Value)
            values      (@MiniProfilerId,
             @ParentSqlTimingId,
             @Name,
             @DbType,
             @Size,
             @Value)";

            foreach (var p in st.Parameters)
            {
                conn.Execute(sql, new
                {
                    MiniProfilerId = profiler.Id,
                    ParentSqlTimingId = st.Id,
                    Name = p.Name.Truncate(130),
                    DbType = p.DbType.Truncate(50),
                    Size = p.Size,
                    Value = p.Value
                });
            }
        }
예제 #19
0
 public void Update(Search entity)
 {
     using (_connection = Utilities.Database.GetProfiledOpenConnection())
     {
         const string query = "UPDATE Searches SET Title = @Title, AllOfTheseWords = @AllOfTheseWords, ThisExactPhrase = @ThisExactPhrase, AnyOfTheseWords = @AnyOfTheseWords, NoneOfTheseWords = @NoneOfTheseWords, NearThisPlace = @NearThisPlace, Radius = @Radius, ResultType = @ResultType WHERE SearchId = @SearchId";
         _connection.Execute(query, entity);
     }
 }
 private static void UpdateFermentationSteps(DbConnection context, DbTransaction transaction, Recipe recipe)
 {
     //Remove mash steps 
     context.Execute("DELETE FROM FermentationSteps WHERE RecipeId = @RecipeId;", new { recipe.RecipeId }, transaction);
     context.Execute("DELETE FROM FermentationStepFermentables WHERE RecipeId = @RecipeId;", new { recipe.RecipeId }, transaction);
     context.Execute("DELETE FROM FermentationStepHops WHERE RecipeId = @RecipeId;", new { recipe.RecipeId }, transaction);
     context.Execute("DELETE FROM FermentationStepOthers WHERE RecipeId = @RecipeId ;", new { recipe.RecipeId }, transaction);
     //Add mash steps
     foreach (var fermentationStep in recipe.FermentationSteps)
     {
         fermentationStep.RecipeId = recipe.RecipeId;
         AddFermentationStep(context, transaction, fermentationStep);
     }
 }
        private void UpdateUserSocials(DbConnection context, DbTransaction transaction, User user)
        {
            var userSocials = context.Query<UserSocial>("SELECT * FROM UserSocials WHERE Username = @Username",
                new { user.Username }, transaction);

            context.Execute("DELETE FROM UserSocials WHERE Username = @Username and SocialId = @SocialId;",
                userSocials.Where(
                    u => user.Socials.All(s => u.SocialId != s.SocialId)),
                transaction);

            context.Execute(
                "UPDATE UserSocials set Site = @Site, Url = @Url WHERE Username = @Username and SocialId = @SocialId;",
                user.Socials, transaction);

            context.Execute("INSERT UserSocials(Username,Site,Url) VALUES(@Username,@Site,@Url);",
                user.Socials.Where(
                    s => userSocials.All(u => s.Username != u.Username && u.SocialId != s.SocialId)).Select(s => new { user.Username, s.Site, s.Url }),
                transaction);
        }
        private static void AddRecipe(Recipe recipe, DbConnection context, DbTransaction transaction)
        {

            context.Execute("INSERT Recipes(RecipeId,Volume,Notes,OG,FG,Efficiency,TotalBoilTime) " +
                            "VALUES(@RecipeId,@Volume,@Notes,@OG,@FG,@Efficiency,@TotalBoilTime);",
                new
                {
                    recipe.RecipeId,
                    recipe.Volume,
                    recipe.Notes,
                    recipe.OG,
                    recipe.FG,
                    recipe.Efficiency,
                    recipe.TotalBoilTime
                }, transaction);

            SetStepNumber(recipe);
            if (recipe.MashSteps != null)
            {
                foreach (var mashStep in recipe.MashSteps)
                {
                    mashStep.RecipeId = recipe.RecipeId;
                    AddMashStep(context, transaction, mashStep);
                }
            }
            if (recipe.BoilSteps != null)
            {
                foreach (var boilStep in recipe.BoilSteps)
                {
                    boilStep.RecipeId = recipe.RecipeId;
                    AddBoilStep(context, transaction, boilStep);
                }
            }

            if (recipe.FermentationSteps != null)
            {
                foreach (var fermentationStep in recipe.FermentationSteps)
                {
                    fermentationStep.RecipeId = recipe.RecipeId;
                    AddFermentationStep(context, transaction, fermentationStep);
                }
            }
        }
예제 #23
0
 public int Insert(Search entity)
 {
     using (_connection = Utilities.Database.GetProfiledOpenConnection())
     {
         const string query = "INSERT INTO Searches (Title, AllOfTheseWords, ThisExactPhrase, AnyOfTheseWords, NoneOfTheseWords, NearThisPlace, Radius, ResultType) " +
                              "VALUES (@Title, @AllOfTheseWords, @ThisExactPhrase, @AnyOfTheseWords, @NoneOfTheseWords, @NearThisPlace, @Radius, @ResultType)";
         return _connection.Execute(query, entity);
     }
 }
 private void UpdateRsvp(RSVP rsvp, DbConnection connection)
 {
     // Future has IsDirtyProperty...
     connection.Execute(@"update Rsvp set " +
         "DinnerID = @DinnerID, " +
         "AttendeeName = @AttendeeName, " +
         "AttendeeNameId = @AttendeeNameId " +
         "WHERE " +
         "DinnerId = @id ",
     new
     {
         id = rsvp.RsvpID,
         rsvp.DinnerID,
         rsvp.AttendeeName,
         rsvp.AttendeeNameId,
     });
 }
 private void UpdateDinner(Dinner dinner, DbConnection connection)
 {
     // Future has IsDirtyProperty...
     connection.Execute(@"update Dinners set " +
         "Title = @Title, " +
         "EventDate = @EventDate, " +
         "Description = @Description, " +
         "HostedBy = @HostedBy, " +
         "ContactPhone = @ContactPhone, " +
         "Address = @Address, " +
         "Country = @Country, " +
         "Latitude = @Latitude, " +
         "Longitude = @Longitude, " +
         "HostedById = @HostedById " +
         "WHERE " +
         "DinnerId = @id ",
     new
     {
         id = dinner.DinnerID,
         dinner.Title,
         dinner.EventDate,
         dinner.Description,
         dinner.HostedBy,
         dinner.ContactPhone,
         dinner.Address,
         dinner.Country,
         dinner.Latitude,
         dinner.Longitude,
         dinner.HostedById
     });
 }
 private static void UpdateRecipe(DbConnection context, DbTransaction transaction, Recipe recipe)
 {
     context.Execute("UPDATE Recipes set Volume = @Volume, Notes = @Notes,OG = @OG,FG = @FG, Efficiency = @Efficiency, TotalBoilTime = @TotalBoilTime " +
                    "WHERE RecipeId = @RecipeId", recipe, transaction);
     SetStepNumber(recipe);
     UpdateMashSteps(context, transaction, recipe);
     UpdateBoilSteps(context, transaction, recipe);
     UpdateFermentationSteps(context, transaction, recipe);
 }
        /// <summary>
        /// Saves parameter SqlTiming to the dbo.MiniProfilerSqlTimings table.
        /// </summary>
        protected virtual void SaveSqlTiming(DbConnection conn, MiniProfiler profiler, SqlTiming st)
        {
            const string sql =
            @"insert into MiniProfilerSqlTimings
            (Id,
             MiniProfilerId,
             ParentTimingId,
             ExecuteType,
             StartMilliseconds,
             DurationMilliseconds,
             FirstFetchDurationMilliseconds,
             IsDuplicate,
             StackTraceSnippet,
             CommandString)
            values      (@Id,
             @MiniProfilerId,
             @ParentTimingId,
             @ExecuteType,
             @StartMilliseconds,
             @DurationMilliseconds,
             @FirstFetchDurationMilliseconds,
             @IsDuplicate,
             @StackTraceSnippet,
             @CommandString)";

            conn.Execute(sql, new
            {
                Id = st.Id,
                MiniProfilerId = profiler.Id,
                ParentTimingId = st.ParentTiming.Id,
                ExecuteType = st.ExecuteType,
                StartMilliseconds = st.StartMilliseconds,
                DurationMilliseconds = st.DurationMilliseconds,
                FirstFetchDurationMilliseconds = st.FirstFetchDurationMilliseconds,
                IsDuplicate = st.IsDuplicate,
                StackTraceSnippet = st.StackTraceSnippet.Truncate(200),
                CommandString = st.CommandString
            });

            if (st.Parameters != null && st.Parameters.Count > 0)
            {
                SaveSqlTimingParameters(conn, profiler, st);
            }
        }
 private void AddBrewers(Beer beer, DbConnection context, DbTransaction transaction)
 {
     //TODO: FIX THIS.
     if (beer.Brewers == null || !beer.Brewers.Any()) return;
     //foreach (var userBeer in beer.Brewers)
     //{
     //    userBeer.Username = userBeer.Username.ToLower();
     //}
     var brewers = beer.Brewers.DistinctBy(u => u.Username.ToLower());
     var distinct =  brewers.Select(b => new {beer.BeerId, b.Username, b.Confirmed});
     context.Execute("INSERT UserBeers(BeerId,Username,Confirmed) VALUES(@BeerId,@Username,@Confirmed);", distinct, transaction);
 }
        private void UpdateBreweryMembers(DbConnection context, DbTransaction transaction, Brewery brewery)
        {
            var breweryMembers = context.Query<BreweryMember>(
                "SELECT * FROM BreweryMembers WHERE BreweryId = @BreweryId", new { brewery.BreweryId }, transaction);

            context.Execute("DELETE FROM BreweryMembers WHERE BreweryId = @BreweryId and MemberUsername = @MemberUsername;",
                breweryMembers.Where(bm => brewery.Members.All(m => bm.MemberUsername != m.MemberUsername)).Select(bm => new { brewery.BreweryId, bm.MemberUsername }), transaction);

            context.Execute(
                "UPDATE BreweryMembers set Role = @Role, Confirmed = @Confirmed WHERE BreweryId = @BreweryId and MemberUsername = @MemberUsername;",
                brewery.Members.Where(m => breweryMembers.Any(bm => m.MemberUsername == bm.MemberUsername)), transaction);

            context.Execute("INSERT BreweryMembers(BreweryId,MemberUsername,Role,Confirmed) VALUES(@BreweryId,@MemberUsername,@Role,@Confirmed);",
                brewery.Members.Where(m => breweryMembers.All(bm => m.MemberUsername != bm.MemberUsername)).Select(bm => new { brewery.BreweryId, bm.MemberUsername, bm.Role, bm.Confirmed }), transaction);

        }
        private static void AddBoilStep(DbConnection context, DbTransaction transaction, BoilStep boilStep)
        {
            context.Execute(
                "INSERT BoilSteps(Length,Volume,Notes,RecipeId,StepNumber)" +
                "VALUES(@Length,@Volume,@Notes,@RecipeId,@StepNumber)", boilStep, transaction);


            if (boilStep.Fermentables != null)
            {
                var duplicates = boilStep.Fermentables.GroupBy(f => f.FermentableId).Where(g => g.Count() > 1).Select(g => g.Key);
                if (duplicates.Any())
                {
                    boilStep.Fermentables = boilStep.Fermentables.GroupBy(o => o.FermentableId)
                        .Select(g => g.Skip(1).Aggregate(
                        g.First(), (a, o) => { a.Amount += o.Amount; return a; })).ToList();
                }
                context.Execute(
                    "INSERT BoilStepFermentables(RecipeId,StepNumber,FermentableId,Amount,Lovibond,PPG) " +
                    "VALUES(@RecipeId,@StepNumber,@FermentableId,@Amount,@Lovibond,@PPG);",
                    boilStep.Fermentables.Select(f => new
                    {
                        boilStep.RecipeId,
                        boilStep.StepNumber,
                        f.FermentableId,
                        f.Amount,
                        f.Lovibond,
                        f.PPG,
                    }), transaction);
            }

            if (boilStep.Hops != null)
            {
                var duplicates = boilStep.Hops.GroupBy(f => f.HopId).Where(g => g.Count() > 1).Select(g => g.Key);
                if (duplicates.Any())
                {
                    boilStep.Hops = boilStep.Hops.GroupBy(o => o.Hop)
                        .Select(g => g.Skip(1).Aggregate(
                        g.First(), (a, o) => { a.Amount += o.Amount; return a; })).ToList();
                }
                context.Execute(
                    "INSERT BoilStepHops(RecipeId,StepNumber,HopId,Amount,AAValue,HopFormId) " +
                    "VALUES(@RecipeId,@StepNumber,@HopId,@Amount,@AAValue,@HopFormId);",
                    boilStep.Hops.Select(h => new
                    {
                        boilStep.RecipeId,
                        boilStep.StepNumber,
                        h.HopId,
                        h.HopFormId,
                        h.AAValue,
                        h.Amount
                    }), transaction);
            }

            if (boilStep.Others != null)
            {
                var duplicates = boilStep.Others.GroupBy(f => f.OtherId).Where(g => g.Count() > 1).Select(g => g.Key);
                if (duplicates.Any())
                {
                    boilStep.Others = boilStep.Others.GroupBy(o => o.OtherId)
                        .Select(g => g.Skip(1).Aggregate(
                        g.First(), (a, o) => { a.Amount += o.Amount; return a; })).ToList();
                }
                context.Execute(
                    "INSERT BoilStepOthers(RecipeId,StepNumber,OtherId,Amount) " +
                    "VALUES(@RecipeId,@StepNumber,@OtherId,@Amount);",
                    boilStep.Others.Select(o => new
                    {
                        boilStep.RecipeId,
                        boilStep.StepNumber,
                        o.Amount,
                        o.OtherId
                    }), transaction);
            }
        }
예제 #31
0
 public void DropTableIfExists(DbConnection db, TableName table)
 {
     db.Execute($"drop table if exists {_utils.EscapeTableName(table)}");
 }