Esempio n. 1
0
 public override bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship)
 {
                 #if WFDESIGN_LOG_MEMBERRELATIONSHIPSERVICE
     LoggingService.Debug("MemberRelationshipService: SupportsRelationship called, source=" + ToString(source) + ", relationship=" + ToString(relationship));
                 #endif
     return(true);
 }
        public void Indexer_NullSourceMember_ThrowsArgumentNullException()
        {
            var service = new TestMemberRelationshipService();

            Assert.Throws <ArgumentNullException>("sourceMember", () => service[new object(), null]);
            Assert.Throws <ArgumentNullException>("sourceMember", () => service[new object(), null] = new MemberRelationship());
        }
        public void Ctor_Default()
        {
            var memberRelationship = new MemberRelationship();

            Assert.Null(memberRelationship.Owner);
            Assert.Null(memberRelationship.Member);
            Assert.True(memberRelationship.IsEmpty);
        }
Esempio n. 4
0
        protected override MemberRelationship GetRelationship(MemberRelationship source)
        {
            LoggingService.Debug("MemberRelationshipService: GetRelationship called, source=" + ToString(source));
            var mrs = base.GetRelationship(source);

            LoggingService.Debug("MemberRelationshipService: -> returning " + ToString(mrs));
            return(mrs);
        }
        public void Empty_Get_ReturnsExpected()
        {
            MemberRelationship memberRelationship = MemberRelationship.Empty;

            Assert.Null(memberRelationship.Owner);
            Assert.Null(memberRelationship.Member);
            Assert.True(memberRelationship.IsEmpty);
        }
 public void Equals_Other_ReturnsExpected(MemberRelationship memberRelationship, object other, bool expected)
 {
     Assert.Equal(expected, memberRelationship.Equals(other));
     if (other is MemberRelationship otherMemberRelationship)
     {
         Assert.Equal(expected, memberRelationship == otherMemberRelationship);
         Assert.Equal(!expected, memberRelationship != otherMemberRelationship);
     }
 }
        public void Indexer_SetNotSupported_ThrowsArgumentException(object owner)
        {
            MemberDescriptor   member = TypeDescriptor.GetProperties(typeof(TestClass))[0];
            MemberRelationship source = new MemberRelationship(owner, member);

            var service = new NotSupportingMemberRelationshipService();

            Assert.Throws <ArgumentException>(null, () => service[source] = source);
        }
        public void Ctor_Owner_Member()
        {
            var owner = new object();
            MemberDescriptor member = new MockPropertyDescriptor();
            var memberRelationship  = new MemberRelationship(owner, member);

            Assert.Same(owner, memberRelationship.Owner);
            Assert.Same(member, memberRelationship.Member);
            Assert.False(memberRelationship.IsEmpty);
        }
        public void Indexer_NullSourceOwner_ThrowsArgumentNullException()
        {
            MemberDescriptor member = TypeDescriptor.GetProperties(typeof(TestClass))[0];

            var service = new TestMemberRelationshipService();

            Assert.Throws <ArgumentNullException>("sourceOwner", () => service[null, member]);
            Assert.Throws <ArgumentNullException>("sourceOwner", () => service[null, member] = new MemberRelationship());

            Assert.Throws <ArgumentException>("source", () => service[new MemberRelationship()]);
            Assert.Throws <ArgumentException>("source", () => service[new MemberRelationship()] = new MemberRelationship());
        }
        public void Indexer_SourceOwnerSourceMember_Success()
        {
            var owner = new object();
            MemberDescriptor member = TypeDescriptor.GetProperties(typeof(TestClass))[0];

            MemberRelationship memberRelationship = new MemberRelationship(new object(), TypeDescriptor.GetProperties(typeof(TestClass))[1]);

            var service = new TestMemberRelationshipService();

            service[owner, member] = memberRelationship;
            Assert.Equal(memberRelationship, service[owner, member]);
        }
        public static IEnumerable <object> Equals_TestData()
        {
            var owner1 = new object();
            var owner2 = new object();
            MemberDescriptor member1 = TypeDescriptor.GetProperties(typeof(TestClass))[0];
            MemberDescriptor member2 = TypeDescriptor.GetProperties(typeof(TestClass))[1];

            var memberRelationship = new MemberRelationship(owner1, member1);

            yield return(new object[] { memberRelationship, memberRelationship, true });

            yield return(new object[] { memberRelationship, new MemberRelationship(owner1, member1), true });

            yield return(new object[] { memberRelationship, new MemberRelationship(owner2, member1), false });

            yield return(new object[] { memberRelationship, new MemberRelationship(owner1, member2), false });

            yield return(new object[] { memberRelationship, new object(), false });

            yield return(new object[] { memberRelationship, null, false });
        }
	public static bool op_Equality(MemberRelationship left, MemberRelationship right) {}
        public void GetHashCode_InvokeMultipleTimesWithoutOwner_ReturnsEqual()
        {
            var memberRelationship = new MemberRelationship();

            Assert.Equal(memberRelationship.GetHashCode(), memberRelationship.GetHashCode());
        }
        public void GetHashCode_InvokeMultipleTimesWithOwner_ReturnsEqual()
        {
            var memberRelationship = new MemberRelationship(new object(), TypeDescriptor.GetProperties(typeof(TestClass))[0]);

            Assert.Equal(memberRelationship.GetHashCode(), memberRelationship.GetHashCode());
        }
	// Methods
	public abstract virtual bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship) {}
 protected override MemberRelationship GetRelationship(MemberRelationship source)
 {
     return(base.GetRelationship(source));
 }
 internal RelationshipEntry(MemberRelationship rel)
 {
     _owner    = new WeakReference(rel.Owner);
     _member   = rel.Member;
     _hashCode = rel.Owner == null ? 0 : rel.Owner.GetHashCode();
 }
Esempio n. 18
0
 static string ToString(MemberRelationship mrs)
 {
     return("[MR: IsEmpty=" + mrs.IsEmpty + ", Owner=[" + (mrs.Owner == null ? "<null>" : mrs.Owner.ToString()) + "], Member=[" + (mrs.Member == null ? "<null>" : mrs.Member.Name) + "]]");
 }
Esempio n. 19
0
 public override bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship)
 {
     return(true);
 }
Esempio n. 20
0
 // Methods
 public abstract virtual bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship)
 {
 }
        public async Task <IActionResult> ProcessRequest(string userId, int type)
        {
            //能稍微解释一下这个函数为啥和其他的长得不一样嘛,你是说async吗 把一个不是async的函数改造成async方法就是,价格async,然后把原来的return type讨一个Task 猴
            //说一下为啥要async,因为这个method显然牵扯到了数据库的相关操作,对数据库的操作一般来说比较耗时,所以用async函数,里面对耗时的步骤使用await xxxxAsync()这样的,可以避免阻塞提升并发能力 ok
            //先校验userId是否存在
            var selfUser = await _userManager.GetUserAsync(User);      //这个是自己

            var targetUser = await _userManager.FindByIdAsync(userId); //这个是userId对应的User

            if (targetUser.Id == selfUser.Id)
            {
                return(Json("Cannot send request to yourself!"));
            }
            //然后查找数据库里面是否已经有了这两个人的相关记录

            using (var db = new ApplicationDbContext(_configuration.GetConnectionString("DefaultConnection")))
            {
                var myRelations = db.MemberRelationship.Where(i => (i.SourceUser == selfUser.Id || i.TargetUser == selfUser.Id));//both pending and existing relationships
                if (myRelations.Where(i => ((i.SourceUser == targetUser.Id) || (i.TargetUser == targetUser.Id)) && i.Result == 1).ToList().Count != 0)
                {
                    return(Json("Request failed. You already have a relationship with the user you selected."));
                }
                else
                {
                    if (selfUser == targetUser)
                    {
                        return(Json("You cannot send requests to yourself."));
                    } // this is a repetition but whatever.....
                    else
                    {
                        if (type == 1)
                        {
                            if (selfUser.Spouse != null || targetUser.Spouse != null)
                            {
                                return(Json("Request failed. Either you or the user you selected is already married."));
                            }
                            else
                            {
                                //TODO: figure out how to efficiently check whether the user has any pending marriage requests.
                                var pending = myRelations.Where(i => i.Result == null && i.Relationship == 1).ToList(); //current user has pending marriage requests
                                if (pending.Count != 0)
                                {
                                    return(Json("Request failed. Please process all your pending marriage requests in the My Family page before sending a new request."));
                                }
                                else
                                {
                                    var record = new MemberRelationship
                                    {
                                        SourceUser   = selfUser.Id,
                                        TargetUser   = targetUser.Id,
                                        Relationship = type,
                                        ApplyingTime = DateTime.Now
                                    };
                                    db.MemberRelationship.Add(record);
                                    await db.SaveChangesAsync();

                                    return(Json("Successful."));
                                }
                            }
                        }
                        else
                        {
                            if (selfUser.Spouse == null)
                            {
                                return(Json("Request failed. You are not yet married therefore cannot adopt any children."));
                            }
                            else
                            {
                                var spouse = await _userManager.FindByIdAsync(selfUser.Spouse);

                                if (selfUser.Privilege == 0 || spouse.Privilege == 0)
                                { //common use has privilege 0; member 1; committee 2
                                    return(Json("Request failed. You and/or your spouse are not yet authorized as a CCS member therefore cannot adopt any children."));
                                }
                                else
                                {
                                    if (targetUser.Parent1 != null || targetUser.Parent2 != null)
                                    {
                                        return(Json("Request failed. The user you selected already has parents."));
                                    }
                                    else
                                    {
                                        if (selfUser.Privilege == 1 && spouse.Privilege == 1)
                                        {
                                            if (selfUser.Child1 == null || selfUser.Child2 == null)
                                            {
                                                var record = new MemberRelationship
                                                {
                                                    SourceUser   = selfUser.Id,
                                                    TargetUser   = targetUser.Id,
                                                    Relationship = type,
                                                    ApplyingTime = DateTime.Now
                                                };
                                                db.MemberRelationship.Add(record);
                                                await db.SaveChangesAsync();

                                                return(Json("Successful."));
                                            }
                                            else
                                            {
                                                return(Json("Request failed, you already have the maximum number of children in your family."));
                                            }
                                        }
                                        else
                                        {
                                            if (selfUser.Privilege == 2 ^ spouse.Privilege == 2)
                                            { //exclusive or -- only one in the couple is a committee member
                                                if (selfUser.Child1 == null || selfUser.Child2 == null || selfUser.Child3 == null)
                                                {
                                                    var record = new MemberRelationship
                                                    {
                                                        SourceUser   = selfUser.Id,
                                                        TargetUser   = targetUser.Id,
                                                        Relationship = type,
                                                        ApplyingTime = DateTime.Now
                                                    };
                                                    db.MemberRelationship.Add(record);
                                                    await db.SaveChangesAsync();

                                                    return(Json("Successful."));
                                                }
                                                else
                                                {
                                                    return(Json("Request failed, you already have the maximum number of children in your family."));
                                                }
                                            }
                                            else
                                            { // the couple are both in the committee
                                                if (selfUser.Child1 == null || selfUser.Child2 == null || selfUser.Child3 == null || selfUser.Child4 == null)
                                                {
                                                    var record = new MemberRelationship
                                                    {
                                                        SourceUser   = selfUser.Id,
                                                        TargetUser   = targetUser.Id,
                                                        Relationship = type,
                                                        ApplyingTime = DateTime.Now
                                                    };
                                                    db.MemberRelationship.Add(record);
                                                    await db.SaveChangesAsync();

                                                    return(Json("Successful."));
                                                }
                                                else
                                                {
                                                    return(Json("Request failed, you already have the maximum number of children in your family."));
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            //你要不把刚才的代码撤销回来我好有个,刚那个有问题啊,只是保证了同样的两个人之间只有一个记录而已 型那我回头再想想 那个Any(i=>....)可以判断是否有满足条件的记录

            //稍等下啊,两个问题
            //插数据的时候不需要给他赋Id的值吗,id是自动增长的字段,不赋值,它会自动便。并且在你SaveChanges执行之后,那个record的Id会被自动赋值成这个记录对应的Id ok
            //然后,目前这些提示信息都存在json数据里面,这个还没有被调用吧?是啊, 我现在就要写这块 okok我就确认一下 等等 我去上个厕所 马上回来 回来了神速 那可不
        }
 public override bool SupportsRelationship(MemberRelationship source, MemberRelationship relationship) => true;
        public async Task <IActionResult> ConfirmRelationship(int i)
        {
            string Source;
            string OtherParent;
            int    Type;

            using (var db = new ApplicationDbContext(_configuration.GetConnectionString("DefaultConnection")))
            {
                var relation = await db.MemberRelationship.FindAsync(i);

                var sourceUser = await _userManager.FindByIdAsync(relation.SourceUser);

                var targetUser = await _userManager.FindByIdAsync(relation.TargetUser);

                var spouse = await _userManager.FindByIdAsync(sourceUser.Spouse);

                relation.Result = 1;
                if (relation.Relationship == 1)
                {
                    sourceUser.Spouse = relation.TargetUser;
                    targetUser.Spouse = relation.SourceUser;
                }
                else
                {
                    if (sourceUser.Child1 == null)
                    { //remember to add if statements when sending the request!!
                        sourceUser.Child1  = relation.TargetUser;
                        spouse.Child1      = relation.TargetUser;
                        targetUser.Parent1 = relation.SourceUser;
                        targetUser.Parent2 = sourceUser.Spouse; //these establishes the relationships among the parents and the child; but I also need to add another registry in the database for the spouse-child relationship
                        var record = new MemberRelationship
                        {
                            SourceUser   = spouse.Id,
                            TargetUser   = targetUser.Id, //this is the child
                            Relationship = 2,
                            Result       = 1,
                            ApplyingTime = DateTime.Now
                        };
                        db.MemberRelationship.Add(record); //this adds the spouse-child relationship in the database
                    }
                    else
                    { //hopefully you've already tested that at least one of them is null
                        if (sourceUser.Child2 == null)
                        {
                            sourceUser.Child2  = relation.TargetUser;
                            spouse.Child2      = relation.TargetUser;
                            targetUser.Parent1 = relation.SourceUser;
                            targetUser.Parent2 = sourceUser.Spouse;
                            var record = new MemberRelationship
                            {
                                SourceUser   = spouse.Id,
                                TargetUser   = targetUser.Id, //this is the child
                                Relationship = 2,
                                Result       = 1,
                                ApplyingTime = DateTime.Now
                            };
                            db.MemberRelationship.Add(record); //this adds the spouse-child relationship in the database
                        }
                        else
                        {
                            if (sourceUser.Child3 == null)
                            {
                                sourceUser.Child3  = relation.TargetUser;
                                spouse.Child3      = relation.TargetUser;
                                targetUser.Parent1 = relation.SourceUser;
                                targetUser.Parent2 = sourceUser.Spouse;
                                var record = new MemberRelationship
                                {
                                    SourceUser   = spouse.Id,
                                    TargetUser   = targetUser.Id, //this is the child
                                    Relationship = 2,
                                    Result       = 1,
                                    ApplyingTime = DateTime.Now
                                };
                                db.MemberRelationship.Add(record); //this adds the spouse-child relationship in the database
                            }
                            else
                            {
                                sourceUser.Child4  = relation.TargetUser;
                                spouse.Child4      = relation.TargetUser;
                                targetUser.Parent1 = relation.SourceUser;
                                targetUser.Parent2 = sourceUser.Spouse;
                                var record = new MemberRelationship
                                {
                                    SourceUser   = spouse.Id,
                                    TargetUser   = targetUser.Id, //this is the child
                                    Relationship = 2,
                                    Result       = 1,
                                    ApplyingTime = DateTime.Now
                                };
                                db.MemberRelationship.Add(record); //this adds the spouse-child relationship in the database
                            }
                        }
                    }
                }
                await db.SaveChangesAsync();

                await _userManager.UpdateAsync(sourceUser);

                await _userManager.UpdateAsync(targetUser);

                Source      = sourceUser.UserName;
                OtherParent = (await _userManager.FindByIdAsync(sourceUser.Spouse))?.UserName;
                Type        = relation.Relationship;
                var test = Json(new { Source, OtherParent, Type });

                return(Json(new { Source, OtherParent, Type }));
            }
            //老哥你要不先看一下marriage那个请求  adoption的我还没有试过所以可能会出其他问题。。你这里有些东西可能拿回来是null然后你没判断直接获取他的成员了, 这样就抛exception了
            //children这块是null我明白,因为我之前在processrequest的时候还有一些判定没有加
            //但是marriage这个我是真的不懂为啥,你可以试一下 我这边的sourceUser不管怎么样肯定都不会是null的
        } //你的ret定义里面没有parent1和parent2啊 但是目前就没有到那个框里去 现在应该只用了source才对吧
 public static bool op_Inequality(MemberRelationship left, MemberRelationship right)
 {
 }