public void FindByIDFact()
        {
            var membership = default(Membership);

            try
            {
                membership = new Membership(new MembershipEntity());

                var name = new Random().Next().ToString(CultureInfo.InvariantCulture);
                membership = new Membership(new MembershipEntity()
                {
                    Name = name, Password = @"",
                });
                membership.Found += (sender, e) => Assert.NotEqual(MembershipEntity.Empty, e);
                membership.Create();
                Assert.True(0 < membership.ID);

                membership.Find();
                Assert.True(membership.Exists());
            }
            finally
            {
                if (membership != null)
                {
                    membership.Delete();
                }
            }
        }
        public void FindByNameFact()
        {
            var membership = default(Membership);

            try
            {
                var name = new Random().Next().ToString(CultureInfo.InvariantCulture);
                membership = new Membership(new MembershipEntity()
                {
                    Name = name, Password = @"",
                });
                membership.Found += (sender, e) =>
                {
                    var actual = new Membership(new MembershipEntity()
                    {
                        Name = e.Name, Password = null,
                    })
                                 .Find();
                    Assert.True(0 < actual.ID);
                };
                membership.Create();
                membership.Find();
            }
            finally
            {
                if (membership != null)
                {
                    membership.Delete();
                }
            }
        }
        public void UpdateFact()
        {
            var membership = default(Membership);

            try
            {
                var name = new Random().Next().ToString(CultureInfo.InvariantCulture);
                membership = new Membership(new MembershipEntity()
                {
                    Name = name, Password = @"",
                })
                             .Create();
                membership.Found += (sender, e) =>
                {
                    e.Enabled = false;
                    var updated = new Membership(e);
                    updated.Found += (_, __) => Assert.False(__.Enabled);
                    updated.Update();
                    updated.Find();
                };
                membership.Find();
            }
            finally
            {
                if (membership != null)
                {
                    membership.Delete();
                }
            }
        }
        public void CreateFact()
        {
            var membership = default(Membership);

            try
            {
                var name = new Random().Next().ToString(CultureInfo.InvariantCulture);
                membership = new Membership(new MembershipEntity()
                {
                    Name = name, Password = @"",
                });
                membership.Found += (_, __) =>
                {
                    Assert.Equal(membership.ID, __.ID);
                };
                membership.Create();
                Assert.True(0 < membership.ID);

                Assert.True(membership.Exists());
                membership.Find();
            }
            finally
            {
                if (membership != null)
                {
                    membership.Delete();
                }
            }
        }
        public void CreateFact()
        {
            var membership = default(Membership);
            var user       = default(User);

            try
            {
                user = new User(new UserEntity());
                user.Create();

                var name = new Random().Next().ToString(CultureInfo.InvariantCulture);
                membership = new Membership(new MembershipEntity()
                {
                    Name = name,
                });
                membership.Users.Add(user.ID);
                membership.Create();
                membership.Find();

                user.Find();

                Assert.Equal(membership.ID, user.MembershipID);
                Assert.Contains(user.ID, membership.Users);
            }
            finally
            {
                if (user != null)
                {
                    user.Delete();
                }
                if (membership != null)
                {
                    membership.Delete();
                }
            }
        }
Exemple #6
0
        private Channel MergeChannel(Channel sourceCh, Membership destMembers)
        {
            bool    found  = true;         // reset to default
            Channel destCh = (Channel)destMembers.Find(sourceCh.Name, MemberType.Channel, false);

            if (destCh == null)
            {
                found  = false;
                destCh = seqNew.CreateChannel(sourceCh.Name);
                destMembers.Add(destCh);
                destCh.CopyFrom(sourceCh, mergeEffects);
            }
            else
            {
                if (duplicateNameAction == ACTIONuseSecond)
                {
                    //destCh = (Channel)destMember;
                }
                if (duplicateNameAction == ACTIONkeepBoth)
                {
                    destCh = seqNew.CreateChannel(sourceCh.Name);
                    destMembers.Add(destCh);
                }
                if (duplicateNameAction == ACTIONaddNumber)
                {
                    destCh = seqNew.CreateChannel(sourceCh.Name + " (2)");
                    destMembers.Add(destCh);
                }

                if (duplicateNameAction != ACTIONkeepFirst)
                {
                    destCh.CopyFrom(sourceCh, mergeEffects);
                }
            }
            return(destCh);
        }
Exemple #7
0
        private void MergeMembers(Membership destMembers, Membership sourceMembers)
        {
            bool found = true;

            // May be called recursively
            //foreach (IMember sourceMember in sourceMembers) // foreach and enumerable not working, fix!
            for (int smi = 0; smi < sourceMembers.Count; smi++)
            {
                IMember sourceMember = sourceMembers[smi];
                if (sourceMember.MemberType == MemberType.Channel)
                {
                    Channel sourceCh = (Channel)sourceMember;
                    Channel destCh   = MergeChannel(sourceCh, destMembers);
                }

                if (sourceMember.MemberType == MemberType.RGBchannel)
                {
                    found = true;                     // reset to default
                    Channel    destCh    = null;      // placeholder
                    RGBchannel sourceRGB = (RGBchannel)sourceMember;
                    RGBchannel destRGB   = (RGBchannel)destMembers.Find(sourceRGB.Name, MemberType.RGBchannel, false);
                    if (destRGB == null)
                    {
                        found   = false;
                        destRGB = seqNew.CreateRGBchannel(sourceRGB.Name);
                        destMembers.Add(destRGB);

                        MergeRGBchildren(sourceRGB, destRGB);
                    }
                    else
                    {
                        if (duplicateNameAction == ACTIONuseSecond)
                        {
                            MergeRGBchildren(sourceRGB, destRGB);
                        }
                        if (duplicateNameAction == ACTIONkeepBoth)
                        {
                            destRGB = seqNew.CreateRGBchannel(sourceRGB.Name);
                            destMembers.Add(destRGB);

                            MergeRGBchildren(sourceRGB, destRGB);
                        }
                        if (duplicateNameAction == ACTIONaddNumber)
                        {
                            destRGB = seqNew.CreateRGBchannel(sourceRGB.Name + " (2)");
                            destMembers.Add(destRGB);

                            MergeRGBchildren(sourceRGB, destRGB);
                        }
                    }
                }

                if (sourceMember.MemberType == MemberType.ChannelGroup)
                {
                    ChannelGroup sourceGroup = (ChannelGroup)sourceMember;
                    ChannelGroup destGroup   = (ChannelGroup)destMembers.Find(sourceGroup.Name, MemberType.ChannelGroup, true);



                    // Should only happen once
                    if (destGroup.SavedIndex == 31)
                    {
                        System.Diagnostics.Debugger.Break();
                    }



                    //Recurse
                    MergeMembers(destGroup.Members, sourceGroup.Members);
                }
            }             // end loop thru 2nd Sequence's Track Items
        }