コード例 #1
0
        public void SaveTransactionToLineItemMapping(int clientId, List <TransactionLineItemMapping> transactionLineItemMappings, int modifyingUserId)
        {
            Contract.Requires <ArgumentOutOfRangeException>(clientId > 0, "A clientId less than or equal to zero is invalid, and likely indicates the clientId was not set properly");
            Contract.Requires <ArgumentNullException>(transactionLineItemMappings != null, "transactionLineItemsMappings cannot be null");
            Contract.Requires <ArgumentOutOfRangeException>(modifyingUserId > 0, "A modifyingUserId less than or equal to zero is invalid, and likely indicates the modifyingUserId was not set properly");


            Dictionary <int, Models.TransactionLineItemMapping> existingMappings = GetExistingLineItemMappings(transactionLineItemMappings);

            foreach (TransactionLineItemMapping tlim in transactionLineItemMappings)
            {
                Models.TransactionLineItemMapping modelTlim = null;

                if (existingMappings.ContainsKey(tlim.TransactionLineItemMappingId))
                {
                    modelTlim = existingMappings[tlim.TransactionLineItemMappingId];
                }
                else
                {
                    modelTlim = new Models.TransactionLineItemMapping();
                    modelTlim.TransactionId = tlim.TransactionId;
                    modelTlim.LineItemId    = tlim.LineItemId;
                }

                modelTlim.Amount       = tlim.Amount;
                modelTlim.DateModified = System.DateTime.Now;
                modelTlim.ModifiedBy   = modifyingUserId;

                SaveTransactionLineItemMapping(clientId, modelTlim, modifyingUserId, existingMappings.ContainsKey(modelTlim.TransactionLineItemMappingId));
            }
        }
コード例 #2
0
        public void DeleteTransactionLineItemMapping(int clientId, int mappingId)
        {
            Contract.Requires <ArgumentOutOfRangeException>(clientId > 0, "A clientId less than or equal to zero is invalid, and likely indicates the clientId was not set properly");
            Contract.Requires <ArgumentOutOfRangeException>(mappingId > 0, "A mappingId less than or equal to zero is invalid, and likely indicates the mappingId was not set properly");


            IQueryable <Models.TransactionLineItemMapping> sqlQuery = from tlim in _database.TransactionLineItemMappings
                                                                      join transaction in _database.Transactions on tlim.TransactionId equals transaction.TransactionId
                                                                      where tlim.TransactionLineItemMappingId == mappingId && transaction.ClientID == clientId
                                                                      select tlim;

            Models.TransactionLineItemMapping modelTLIM = sqlQuery.SingleOrDefault();

            if (modelTLIM != null)
            {
                _database.Entry(modelTLIM).State = EntityState.Deleted;
                _database.SaveChanges();
            }
        }
コード例 #3
0
        /// <summary>
        /// Insert or update the Line Item Mapping checking the conditionals to verify the transactionId and LineItemId belong
        /// to the ClientId.
        /// </summary>
        /// <param name="clientId">ClientId to check against</param>
        /// <param name="mapping">The Entity object to insert/update</param>
        /// <param name="modifyingUserId">The user making the change</param>
        /// <param name="existingMapping">Whether Entity exists in the database or not</param>
        private void SaveTransactionLineItemMapping(int clientId, Models.TransactionLineItemMapping mapping, int modifyingUserId, bool existingMapping)
        {
            List <SqlParameter> parameters = new List <SqlParameter>(7);

            parameters.Add(new SqlParameter("@TransactionId", mapping.TransactionId));
            parameters.Add(new SqlParameter("@LineItemId", mapping.LineItemId));
            parameters.Add(new SqlParameter("@Amount", mapping.Amount));
            parameters.Add(new SqlParameter("@DateModified", mapping.DateModified));
            parameters.Add(new SqlParameter("@ModifiedBy", modifyingUserId));
            parameters.Add(new SqlParameter("@ClientId", clientId));

            string sqlQuery;

            if (existingMapping)
            {
                parameters.Add(new SqlParameter("@TransactionLineItemMappingId", mapping.TransactionLineItemMappingId));

                sqlQuery = string.Format(@"update TransactionLineItemMapping 
                                            set TransactionId = @TransactionId, LineItemId = @LineITemId, Amount = @Amount, DateModified = @DateModified, ModifiedBy = @ModifiedBy
                                            from Transactions T
                                            join LineItemDetail L on L.ClientId = T.ClientId
                                            where T.TransactionId = @TransactionId and 
                                                L.PlanLineItemId = @LineitemId and 
                                                TransactionLineItemMappingId = @TransactionLineItemMappingId and
                                                T.clientId = @ClientId");
            }
            else
            {
                sqlQuery = string.Format(@"insert into TransactionLineItemMapping (TransactionId, LineItemId, Amount, DateModified, ModifiedBy)
                                            select T.transactionId, L.PlanLineItemId, @Amount, @DateModified, @ModifiedBy 
                                            from Transactions T
                                            join LineItemDetail L on L.ClientId = T.clientid  
                                            where T.TransactionId = @TransactionId and 
                                                L.PlanLineItemId = @LineItemId and 
                                                T.ClientID = @ClientId");
            }

            _database.Database.ExecuteSqlCommand(sqlQuery, parameters.ToArray());
        }