Exemple #1
0
        public async Task <Result <Guid> > AddSurveyDependent(CreateUserDependentModel model)
        {
            var userId     = new Guid(User.Claims.FirstOrDefault(c => c.Type == "Id").Value);
            var usersurvey = await _userSurveyBiz.GetByUserIdAndSurveyId(userId, model.SurveyId);

            var id = Guid.NewGuid();

            var duplicate = await _repository.FirstOrDefaultAsNoTrackingAsync <UserDependentSurvey>(d =>
                                                                                                    d.UserId == model.UserId && d.UserSurveyId == usersurvey.Data.Id);

            if (duplicate.Success && duplicate.Data != null)
            {
                return(Result <Guid> .Successful(duplicate.Data.Id));
            }

            var linkedUsers =
                await _membershipServiceApi.MembershipLinkedUserApiService.ListByUser(new BaseModel { Id = userId });

            if (linkedUsers.Data != null && linkedUsers.Data.Any() &&
                linkedUsers.Data.Any(l => l.FirstUser.Id == model.UserId))
            {
                var userDependentSurvey = new UserDependentSurvey
                {
                    Id           = Guid.NewGuid(),
                    UserId       = model.UserId,
                    TuitionFee   = model.TuitionFee,
                    UserSurveyId = usersurvey.Data.Id
                };
                _repository.Add(userDependentSurvey);
                await _repository.CommitAsync();

                return(Result <Guid> .Successful(userDependentSurvey.Id));
            }

            var joinRequest = await _membershipServiceApi.MembershipLinkedUserApiService.JoinRequest(
                new CreateLinkedUserModel
            {
                FirstUserId  = model.UserId,
                SecondUserId = userId,
                RelationType = model.RelationType
            });

            if (joinRequest.Success)
            {
                var dependent = new UserDependentSurvey
                {
                    Id           = Guid.NewGuid(),
                    UserId       = model.UserId,
                    UserSurveyId = usersurvey.Data.Id
                };
                _repository.Add(dependent);
                await _repository.CommitAsync();

                return(Result <Guid> .Successful(dependent.Id));
            }

            return(Result <Guid> .Failed(joinRequest.Error));
        }
 public Task <Result> AddDependent(Guid userId, Guid usersurveyId)
 => Result.TryAsync(async() =>
 {
     var userDependentSurvey = new UserDependentSurvey
     {
         Id           = Guid.NewGuid(),
         UserSurveyId = usersurveyId,
         UserId       = userId
     };
     _repository.Add(userDependentSurvey);
     await _repository.CommitAsync();
     return(Result.Successful());
 });
Exemple #3
0
        public async Task <Result> SurveyJoinRequest([FromQuery] Guid surveyId, CreateLinkedUserModel model)
        {
            var joinRequest = await _membershipServiceApi.MembershipLinkedUserApiService.JoinRequest(model);

            var userId = new Guid(User.Claims.FirstOrDefault(c => c.Type == "Id").Value);

            var usersurvey = await _userSurveyBiz.GetByUserIdAndSurveyId(userId, surveyId);

            var userDependentSurvey = new UserDependentSurvey
            {
                Id           = Guid.NewGuid(),
                UserId       = model.FirstUserId.Value,
                UserSurveyId = usersurvey.Data.Id
            };

            _repository.Add(userDependentSurvey);
            await _repository.CommitAsync();

            return(Result.Successful());
        }
        public async Task <Result <object> > Register([FromQuery] string placeid, [FromQuery] Guid surveyId,
                                                      AdvanceRegisterModel model)
        {
            var placeDetail = await _placeApi.PlaceDetail(placeid);

            if (placeDetail.Success)
            {
                model.User.Province   = placeDetail.Data.Item1;
                model.User.City       = placeDetail.Data.Item2;
                model.User.PostalCode = placeDetail.Data.Item3;
                model.User.Address    = placeDetail.Data.Item4;
            }


            var register = await _membershipServiceApi.AuthAuthApiService.Register(model);

            if (register.Success)
            {
                var userId     = new Guid(User.Claims.FirstOrDefault(c => c.Type == "Id").Value);
                var usersurvey = await _userSurveyBiz.GetByUserIdAndSurveyId(userId, model.SurveyId);

                if (usersurvey.Success)
                {
                    var userDependentSurvey = new UserDependentSurvey
                    {
                        Id           = Guid.NewGuid(),
                        UserSurveyId = usersurvey.Data.Id,
                        TuitionFee   = model.User.TuitionFee,
                        UserId       = new Guid((string)register.Data)
                    };
                    _repository.Add(userDependentSurvey);
                }


                if (model.User.Assessments != null && model.User.Assessments.Any())
                {
                    var id = Guid.NewGuid();
                    var userAssessmentSurvey = new UserAssessmentSurvey
                    {
                        Id                 = id,
                        UserId             = new Guid((string)register.Data),
                        UserAssessmentBlob = model.User.Assessments.Select(b => new UserAssessmentBlob
                        {
                            Id     = Guid.NewGuid(),
                            BlobId = b,
                            UserAssesmentSurveyId = id
                        }).ToList(),
                        UserSurveyId = usersurvey.Data.Id
                    };
                    _repository.Add(userAssessmentSurvey);
                }

                if (model.User.ExtraFiles != null && model.User.ExtraFiles.Any())
                {
                    var id    = Guid.NewGuid();
                    var blobs = await _repository.ListAsync <Blob>(b => model.User.ExtraFiles.Contains(b.Id));

                    blobs.Data.ToList().ForEach(b => b.Title = "Dependent_ExtraFile_" + b.Title);
                    var userAssessmentSurvey = new UserAssessmentSurvey
                    {
                        Id                 = id,
                        UserId             = new Guid((string)register.Data),
                        UserAssessmentBlob = model.User.ExtraFiles.Select(b => new UserAssessmentBlob
                        {
                            Id     = Guid.NewGuid(),
                            BlobId = b,
                            UserAssesmentSurveyId = id
                        }).ToList(),
                        UserSurveyId = usersurvey.Data.Id
                    };
                    _repository.Add(userAssessmentSurvey);
                    await _repository.CommitAsync();
                }

                await _repository.CommitAsync();


                return(Result <object> .Successful());
            }

            return(Result <object> .Failed(register.Error));
        }
Exemple #5
0
        public async Task <Result <object> > Register([FromQuery] Guid surveyId,
                                                      CreateSpouseModel model)
        {
            var userId      = new Guid(User.Claims.FirstOrDefault(c => c.Type == "Id").Value);
            var currentUser = await _membershipServiceApi.AuthAuthApiService.Profile(new BaseModel { Id = userId });

            var usersurvey = await _userSurveyBiz.GetByUserIdAndSurveyId(userId, surveyId);

            var dependents =
                await _membershipServiceApi.MembershipLinkedUserApiService.ListByUser(new BaseModel { Id = userId });

            var sp = dependents.Data.FirstOrDefault(ua => ua.RelationType.ToLower().Contains("spouse"));

            if (sp != null)
            {
                var remove =
                    await _membershipServiceApi.MembershipLinkedUserApiService.Remove(new BaseModel { Id = sp.Id });

                var spDependent = await _repository.FirstOrDefaultAsync <UserDependentSurvey>(u =>
                                                                                              u.UserSurveyId == usersurvey.Data.Id && userId == sp.FirstUser.Id);

                if (spDependent.Data != null)
                {
                    _repository.Remove(spDependent.Data);
                }
            }

            bool  success = false;
            Error error   = null;

            Guid spouseId = Guid.Empty;

            if (model.UserId == null)
            {
                var register = await _membershipServiceApi.AuthAuthApiService.Register(new AdvanceRegisterModel
                {
                    SurveyId     = surveyId,
                    RelationType = "Spouse",
                    User         = new CreateUserModel
                    {
                        Address       = currentUser.Data.Address,
                        Province      = currentUser.Data.Province,
                        City          = currentUser.Data.City,
                        Firstname     = model.Firstname,
                        Lastname      = model.Lastname,
                        Gender        = model.Gender,
                        Mobile        = model.Mobile,
                        Email         = model.Email,
                        DateOfBirth   = model.DateOfBirth,
                        Password      = string.IsNullOrEmpty(model.Password) ? "1234" : model.Password,
                        MaritalStatus = MaritalStatus.Married,
                        PostalCode    = currentUser.Data.PostalCode,
                        PoBox         = currentUser.Data.PoBox,
                        UnitNumber    = currentUser.Data.UnitNumber,
                        Receipts      = model.Receipts,
                        SinNumber     = model.SinNumber,
                        RoleId        = new Guid("6C98C773-5CF8-4993-B78B-32AF01858111")
                    }
                });

                success = register.Success;
                if (!success)
                {
                    return(Result <object> .Failed(register.Error));
                }
                spouseId = new Guid((string)register.Data);
                error    = register.Error;
            }

            else
            {
                var spouse = await _membershipServiceApi.AuthAuthApiService.Profile(new BaseModel { Id = model.UserId });

                var joinRequest = await _membershipServiceApi.MembershipLinkedUserApiService.JoinRequest(
                    new CreateLinkedUserModel
                {
                    FirstUserId  = model.UserId.Value,
                    SecondUserId = userId,
                    RelationType = "Spouse"
                });

                success = spouse.Success;
                if (!success)
                {
                    return(Result <object> .Failed(spouse.Error));
                }

                spouseId = model.UserId.Value;
                error    = spouse.Error;
            }

            if (success)
            {
                if (usersurvey.Success)
                {
                    var userDependentSurvey = new UserDependentSurvey
                    {
                        Id           = Guid.NewGuid(),
                        UserSurveyId = usersurvey.Data.Id,
                        UserId       = spouseId
                    };
                    _repository.Add(userDependentSurvey);
                    await _repository.CommitAsync();
                }


                if (model.Assessments != null && model.Assessments.Any())
                {
                    var id = Guid.NewGuid();
                    var userAssessmentSurvey = new UserAssessmentSurvey
                    {
                        Id                 = id,
                        UserId             = spouseId,
                        UserAssessmentBlob = model.Assessments.Select(b => new UserAssessmentBlob
                        {
                            Id     = Guid.NewGuid(),
                            BlobId = b,
                            UserAssesmentSurveyId = id
                        }).ToList(),
                        UserSurveyId = usersurvey.Data.Id
                    };
                    _repository.Add(userAssessmentSurvey);
                    await _repository.CommitAsync();
                }

                if (model.ExtraFiles != null && model.ExtraFiles.Any())
                {
                    var id    = Guid.NewGuid();
                    var blobs = await _repository.ListAsync <Blob>(b => model.ExtraFiles.Contains(b.Id));

                    blobs.Data.ToList().ForEach(b => b.Title = "Spouse_ExtraFile_" + b.Title);
                    var userAssessmentSurvey = new UserAssessmentSurvey
                    {
                        Id                 = id,
                        UserId             = spouseId,
                        UserAssessmentBlob = model.ExtraFiles.Select(b => new UserAssessmentBlob
                        {
                            Id     = Guid.NewGuid(),
                            BlobId = b,
                            UserAssesmentSurveyId = id
                        }).ToList(),
                        UserSurveyId = usersurvey.Data.Id
                    };
                    _repository.Add(userAssessmentSurvey);
                    await _repository.CommitAsync();
                }


                return(Result <object> .Successful());
            }

            return(Result <object> .Failed(error));
        }