Beispiel #1
0
        public async Task CreateClient_ShouldThrowException_On_DuplicateShortKey()
        {
            // Arrange
            var reg = new ClientRegistration {
                Name = "TestClient", ShortKey = "KEY1"
            };
            var mockClient = new Client {
                Name = "TestClient", ShortKey = "KEY1"
            };
            var mockRepo = new Mock <IClientRepository>();

            mockRepo.Setup(x => x.GetClientByShortKey(It.IsAny <string>())).ReturnsAsync(mockClient);
            var sut = new ClientService(mockRepo.Object);
            // Act & Assert
            var ex = await Assert.ThrowsAsync <Exception>(() => sut.CreateClient(reg));

            Assert.True(ex.Message.ToLower() == "short key is already in use");
        }
Beispiel #2
0
        [HttpPost("ClientRegister")]  // api/Accounts/ClientRegister
        public async Task <ActionResult> Register(ClientRegistration userModel)
        {
            var user   = _mapper.Map <User>(userModel);
            var client = _mapper.Map <Client>(userModel);

            var result = await _userManager.CreateAsync(user, userModel.Password);

            if (!result.Succeeded)
            {
                return(Ok(result.Errors));
            }
            await _userManager.AddToRoleAsync(user, "Client");

            db.Clients.Add(client);
            db.SaveChanges();

            return(StatusCode(201));
        }
        public ClientRegistration ValidateToken(string Token)
        {
            ClientRegistration objcr = new ClientRegistration();

            var accountDetail = from ad in _PMSDBEntities.ClientRegistrations
                                where ad.Token == Token
                                select ad;

            if (accountDetail == null)
            {
                objcr = null;
                return(objcr);
            }
            else
            {
                return(accountDetail.FirstOrDefault());
            }
        }
        public ActionResult clientupdate(ClientRegistration reg)
        {
            if (reg.UserId == 0)
            {
                return(RedirectToAction("inbox"));
            }

            if (ModelState.IsValid)
            {
                using (CargoTrackerDbContext db = new CargoTrackerDbContext())
                {
                    var result = db.ClientRegistrations.SingleOrDefault(u => u.UserId == reg.UserId);
                    if (result == null)
                    {
                        return(RedirectToAction("Manageusers"));
                    }

                    result.ShippersFirstName    = reg.ShippersFirstName;
                    result.ShippersLastName     = reg.ShippersLastName;
                    result.ReceiversFirstName   = reg.ReceiversFirstName;
                    result.ReceiversLastName    = reg.ReceiversLastName;
                    result.ReceiversCountryName = reg.ReceiversCountryName;
                    result.ReceiversEmail       = reg.ReceiversEmail;
                    result.ReceiversPhone       = reg.ReceiversPhone;
                    result.ShippersPhone        = reg.ShippersPhone;
                    result.Status           = reg.ShippersPhone;
                    result.TrackingId       = reg.TrackingId;
                    result.weight           = reg.weight;
                    result.TotalFreight     = reg.TotalFreight;
                    result.ReceiversAddress = reg.ReceiversAddress;
                    result.BookingMode      = reg.BookingMode;
                    result.Comment          = reg.Comment;
                    result.CreatedOn        = reg.CreatedOn;
                    result.Invoice          = reg.Invoice;
                    result.PickTime         = reg.PickTime;
                    result.PickupDate       = reg.PickupDate;
                    result.DeliveryMode     = reg.DeliveryMode;
                    result.Description      = reg.Description;
                    db.SaveChanges();
                }
            }

            return(RedirectToAction("Manageusers"));
        }
 public RequestResult RegisterClient([FromBody] ClientRegistration registration)
 {
     if (UserHelper.IsAuthorize(new List <int> {
         (int)UserType.SuperAdmin
     }))
     {
         string        PasswordHash  = SecurityHelper.EncodePassword(registration.Password, SecurityHelper.SALT);
         RequestResult requestResult = new RequestResult();
         try
         {
             if (_accountRepository.IsLoginFree(registration.Login))
             {
                 User userToAdd = new User {
                     Login = registration.Login, Password = PasswordHash, Role = registration.Role, Name = registration.UserName, Surname = registration.UserSurname, Created_at = DateTime.Now
                 };
                 _context.Users.Add(userToAdd);
                 _context.SaveChanges();
                 Client clientToAdd = new Client {
                     Name = registration.Name, Address = registration.Address, PrefixVat_Id = registration.PrefixVat_Id, VAT_Id = registration.VAT_Id.RemoveWhiteSpaces(), Email = registration.Email, User_Id = userToAdd.Id, Created_At = userToAdd.Created_at, PhoneNumber = registration.PhoneNumber.RemoveWhiteSpaces()
                 };
                 _context.Clients.Add(clientToAdd);
                 _context.SaveChanges();
                 requestResult.Status  = true;
                 requestResult.Message = "The client has been registered";
             }
             else
             {
                 requestResult.Status  = false;
                 requestResult.Message = "Login exists in system.";
             }
         }
         catch (Exception ex)
         {
             requestResult.Status  = false;
             requestResult.Message = ex.ToString();
         }
         return(requestResult);
     }
     else
     {
         throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "User don't have acces to this method"));
     }
 }
Beispiel #6
0
        public async Task RegisterClient_Success()
        {
            var clientRegistration = new ClientRegistration()
            {
                AppName    = GetType().Name,
                InstanceId = "instance1",
                Interval   = 1000,
                SdkVersion = "sdk101",
                Started    = DateTimeOffset.UtcNow,
                Strategies = new List <string>
                {
                    "abc"
                }
            };

            var result = await api.RegisterClient(clientRegistration, CancellationToken.None);

            result.Should().Be(true);
        }
        public async Task RegisterClient_WhenInvoked_CompletesSuccessfully()
        {
            var clientRegistration = new ClientRegistration
            {
                AppName    = GetType().Name,
                InstanceId = "instance1",
                Interval   = 1000,
                SdkVersion = "sdk101",
                Started    = DateTimeOffset.UtcNow,
                Strategies = new List <string>
                {
                    "abc"
                }
            };

            var result = await Client.RegisterClient(clientRegistration, CancellationToken.None);

            Assert.True(result);
        }
Beispiel #8
0
        public async Task <Client> CreateClient(ClientRegistration reg)
        {
            // Check that the short key is not already in use
            if (!await ShortKeyAvailable(reg.ShortKey))
            {
                throw new Exception("Short Key is already in use");
            }

            var client = new Client
            {
                Id           = Guid.NewGuid().ToString(),
                Name         = reg.Name,
                SiteUrl      = reg.SiteUrl,
                ShortKey     = reg.ShortKey,
                ClientApiKey = Guid.NewGuid().ToString()
            };

            return(await _clientRepo.CreateClient(client));
        }
Beispiel #9
0
        public async Task CreateClient_ShouldReturn_NonNullClient_WithId()
        {
            // Arrange
            var reg = new ClientRegistration {
                Name = "NewName", ShortKey = "NewKey"
            };
            var mockClient = new Client {
                Id = Guid.NewGuid().ToString()
            };
            var mockRepo = new Mock <IClientRepository>();

            mockRepo.Setup(x => x.GetClientByShortKey(It.IsAny <string>())).ReturnsAsync((Client)null);
            mockRepo.Setup(x => x.CreateClient(It.IsAny <Client>())).ReturnsAsync(mockClient);
            var sut = new ClientService(mockRepo.Object);
            // Act
            var result = await sut.CreateClient(reg);

            // Assert
            Assert.True(result != null);
            Assert.True(result.Id != null);
        }
        public RegisterClientResponse RegisterClient(ClientRegistration registration)
        {
            Client client = new Client()
            {
                ClientName = registration.ClientName
            };

            dbContext.Clients.Add(client);
            dbContext.SaveChanges();

            client = dbContext.Clients.FirstOrDefault(c => c.ClientGuid == client.ClientGuid);

            User user = new User()
            {
                ClientId      = client.ClientId,
                FirstName     = registration.FirstName,
                LastName      = registration.LastName,
                UserName      = registration.UserName,
                Password      = AES.Encrypt(registration.Password),
                MustChangePwd = true
            };

            dbContext.Users.Add(user);

            Application application = new Application()
            {
                ApplicationName = registration.ApplicationName,
                ClientId        = client.ClientId
            };

            dbContext.Applications.Add(application);

            dbContext.SaveChanges();

            return(new RegisterClientResponse()
            {
                ClientId = client.ClientGuid,
                ApplicationId = application.ApplicationGuid
            });
        }
Beispiel #11
0
        public void MergeFrom(ServiceRequest other)
        {
            if (other == null)
            {
                return;
            }
            if (other.Topic.Length != 0)
            {
                Topic = other.Topic;
            }
            switch (other.TypeCase)
            {
            case TypeOneofCase.ClientRegistration:
                if (ClientRegistration == null)
                {
                    ClientRegistration = new global::Ubii.Service.Request.ClientRegistration();
                }
                ClientRegistration.MergeFrom(other.ClientRegistration);
                break;

            case TypeOneofCase.DeviceRegistration:
                if (DeviceRegistration == null)
                {
                    DeviceRegistration = new global::Ubii.Service.Request.DeviceRegistration();
                }
                DeviceRegistration.MergeFrom(other.DeviceRegistration);
                break;

            case TypeOneofCase.Subscription:
                if (Subscription == null)
                {
                    Subscription = new global::Ubii.Service.Request.Subscription();
                }
                Subscription.MergeFrom(other.Subscription);
                break;
            }

            _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
        }
Beispiel #12
0
        /// <summary>
        /// Initializes database, creates and returns ClientRegistration
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        public static ClientRegistration CreateFakeClient(DatabaseContext context)
        {
            ClientRegistration result = null;

            if (!context.ClientState.Any())
            {
                context.ClientState.Add(new ClientState {
                    Id = 1, Text = "app-installed"
                });
                context.ClientState.Add(new ClientState {
                    Id = 2, Text = "app-uninstalled"
                });
                context.ClientState.Add(new ClientState {
                    Id = 3, Text = "app-enabled"
                });
                context.ClientState.Add(new ClientState {
                    Id = 4, Text = "app-disabled"
                });
            }
            var fixture = new Fixture();

            /*
             * fixture.Behaviors.OfType<ThrowingRecursionBehavior>().ToList()
             *  .ForEach(b => fixture.Behaviors.Remove(b));
             * fixture.Behaviors.Add(new OmitOnRecursionBehavior());
             */
            result = fixture.Build <ClientRegistration>()
                     .Without(p => p.ClientState)
                     //.Without(p => p.Deleted)
                     .With(p => p.ClientStateId, 1)
                     .With(p => p.BaseUrl, "https://mockjiracloud.com")
                     .With(p => p.Key, "appkeymock")
                     .Create();
            context.ClientRegistration.Add(result);
            context.SaveChanges();
            return(result);
        }
        public async Task ExecuteAsync(CancellationToken cancellationToken)
        {
            if (settings.SendMetricsInterval == null)
            {
                return;
            }

            var clientRegistration = new ClientRegistration
            {
                AppName    = settings.AppName,
                InstanceId = settings.InstanceTag,
                Interval   = (long)settings.SendMetricsInterval.Value.TotalMilliseconds,
                SdkVersion = settings.SdkVersion,
                Started    = DateTimeOffset.UtcNow,
                Strategies = strategies
            };

            var result = await apiClient.RegisterClient(clientRegistration, cancellationToken).ConfigureAwait(false);

            if (!result)
            {
                // Already logged..
            }
        }
Beispiel #14
0
        internal async Task RegisterClient_WhenServerReturns200Ok_ReturnsTrue(
            UnleashSettings settings,
            [Frozen] Mock <FakeHttpMessageHandler> httpMessageHandler,
            [Frozen] UnleashApiClientRequestHeaders requestHeaders,
            ClientRegistration clientRegistration
            )
        {
            var jsonSerializerSettings = new NewtonsoftJsonSerializerSettings();
            var jsonSerializer         = new NewtonsoftJsonSerializer(jsonSerializerSettings);

            httpMessageHandler.SetupPostRegisterClientRequestForSuccess(requestHeaders);

            var httpClient = new HttpClient(httpMessageHandler.Object)
            {
                BaseAddress = settings.UnleashApi
            };
            var apiClient = new UnleashApiClient(httpClient, jsonSerializer, requestHeaders);

            var successResult = await apiClient.RegisterClient(clientRegistration, CancellationToken.None);

            Assert.True(successResult);

            httpMessageHandler.VerifyAll();
        }
Beispiel #15
0
        public async Task <ActionResult <CorpClient> > Register(ClientRegistration model)
        {
            var data = await service.Register(model);

            return(Ok(data));
        }
Beispiel #16
0
        public IHttpActionResult adviserCreateNewClient_Person(PersonClientCreationBindingModel model)
        {
            //if (!ModelState.IsValid) {
            //    var errors = ModelState.Select(x => x.Value.Errors)
            //               .Where(y => y.Count > 0)
            //               .ToList();
            //}
            if (model != null)                                          //  deleted   && ModelState.IsValid         must put it back afterward
            {
                #region create asp user and send email
                var user = new ApplicationUser
                {
                    Email       = model.email,
                    UserName    = model.email,
                    PhoneNumber = model.contactPhone
                };
                var password    = "******";//Membership.GeneratePassword(10, 0);
                var userManager = Request.GetOwinContext().GetUserManager <ApplicationUserManager>();
                userManager.Create(user, password);
                userManager.AddToRole(user.Id, AuthorizationRoles.Role_Preclient);
                //EmailUtilities.SendEmailToUser(user.Id, "", "", "");//send password
                #endregion



                #region create client profile
                ClientRegistration client = new ClientRegistration
                {
                    CreateOn     = DateTime.Now,
                    ClientNumber = user.Id,
                    FirstName    = model.firstName,
                    MiddleName   = model.middleName,
                    Email        = model.email,
                    LastName     = model.lastName,
                    Phone        = model.contactPhone,
                    ClientType   = BusinessLayerParameters.clientType_person,
                };
                #endregion

                #region create client group or add to existing group
                if (model.isGroupLeader.HasValue && model.isGroupLeader.Value)
                {
                    var adviserNumber             = User.Identity.GetUserId();
                    ClientGroupRegistration group = new ClientGroupRegistration
                    {
//#warning adviser number needs replacement
                        AdviserNumber = adviserNumber,
                        GroupAmount   = model.newGroupAmount,
                        GroupName     = model.newGroupAccountName,
                        CreateOn      = DateTime.Now,
                        client        = client,
                    };
                    edisRepo.CreateNewClientGroupSync(group);
                }
                else
                {
                    client.GroupNumber = model.existingGroupId;
                    edisRepo.CreateNewClientSync(client);
                }

                using (DocX document = DocX.Create("C:\\Test\\" + client.FirstName + "_" + client.LastName + ".docx"))
                {
                    Paragraph paragraph = document.InsertParagraph();
                    paragraph.AppendLine(ClientDocInfo.FirstName + model.firstName);
                    paragraph.AppendLine(ClientDocInfo.MiddleName + model.middleName);
                    paragraph.AppendLine(ClientDocInfo.LastName + model.lastName);
                    paragraph.AppendLine(ClientDocInfo.Email + model.email);
                    paragraph.AppendLine(ClientDocInfo.ContactPhone + model.contactPhone);
                    document.Save();
                }

                string code        = userManager.GenerateEmailConfirmationTokenAsync(user.Id).Result;
                string path        = HttpContext.Current.Server.MapPath("~/EmailTemplate/ConfirmEmail.html");
                var    Url         = new System.Web.Mvc.UrlHelper(HttpContext.Current.Request.RequestContext);
                var    callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Current.Request.Url.Scheme);
                string content     = System.IO.File.ReadAllText(path).Replace("###Name###", user.UserName).Replace("###Confirm###", callbackUrl);
                userManager.SendEmailAsync(user.Id, "Confirm your account", content);

                #endregion


                #region create risk profile if present
                if (model.riskProfile != null)
                {
                    var         riskProfile = model.riskProfile;
                    RiskProfile profile     = new RiskProfile {
                        CapitalLossAttitude    = riskProfile.capitalLossAttitude,
                        ClientID               = edisRepo.GetClientSync(user.Id, DateTime.Now).Id,
                        Comments               = riskProfile.comments,
                        DateCreated            = DateTime.Now,
                        DateModified           = DateTime.Now,
                        IncomeSource           = riskProfile.incomeSource,
                        InvestmentKnowledge    = riskProfile.investmentKnowledge,
                        InvestmentObjective1   = riskProfile.investmentObjective1,
                        InvestmentObjective2   = riskProfile.investmentObjective2,
                        InvestmentObjective3   = riskProfile.investmentObjective3,
                        InvestmentProfile      = riskProfile.investmentProfile,
                        InvestmentTimeHorizon  = riskProfile.investmentTimeHorizon,
                        LongTermGoal1          = riskProfile.longTermGoal1,
                        LongTermGoal2          = riskProfile.longTermGoal2,
                        LongTermGoal3          = riskProfile.longTermGoal3,
                        MedTermGoal1           = riskProfile.medTermGoal1,
                        MedTermGoal2           = riskProfile.medTermGoal2,
                        MedTermGoal3           = riskProfile.medTermGoal3,
                        RetirementAge          = string.IsNullOrEmpty(riskProfile.retirementAge) ? (int?)null : Convert.ToInt32(riskProfile.retirementAge),
                        RetirementIncome       = riskProfile.retirementIncome,
                        RiskAttitude           = riskProfile.riskAttitude,
                        ShortTermAssetPercent  = riskProfile.shortTermAssetPercent,
                        ShortTermEquityPercent = riskProfile.shortTermEquityPercent,
                        ShortTermGoal1         = riskProfile.shortTermGoal1,
                        ShortTermGoal2         = riskProfile.shortTermGoal2,
                        ShortTermGoal3         = riskProfile.shortTermGoal3,
                        ShortTermTrading       = riskProfile.shortTermTrading,
                        riskLevel              = Int32.Parse(riskProfile.riskLevel)
                    };
                    edisRepo.CreateRiskProfileForClient(profile);
                }
                #endregion

                //#region save all changes and return ok
                //db.SaveChanges();
                return(Ok());
                //#endregion
            }
            else
            {
                return(BadRequest(ModelState));
            }
        }
        public async Task <ActionResult <ClientRegistration> > PostClientRegistration(ClientRegistration clientRegistration)
        {
            _context.ClientTable.Add(clientRegistration);
            await _context.SaveChangesAsync();

            return(CreatedAtAction("GetClientRegistration", new { id = clientRegistration.ID }, clientRegistration));
        }
Beispiel #18
0
        public async Task <FraudRegistrationResponse> FraudClientRegistrationPostAsync(ClientRegistration payload, string region = null)
        {
            Signature signatureService = GetSignatureService();
            string    messageSignature = signatureService.Sign(JsonConvert.SerializeObject(payload));

            return(await fraudApi.FraudClientRegistrationPostAsync(
                       CONTENT_TYPE,
                       signatureService.ClientRequestId,
                       GetApiKey(),
                       signatureService.TimeStamp,
                       payload,
                       messageSignature,
                       region
                       ));
        }
 public RegisterClientResponse RegisterClient(ClientRegistration clientRegistration)
 {
     return(testManager.RegisterClient(clientRegistration));
 }
 public async Task <IActionResult> CreateClient([FromBody] ClientRegistration client)
 => new OkObjectResult(await _clientService.CreateClient(client));
Beispiel #21
0
 public IActionResult Create(ClientRegistration clientRegistration)
 {
     lowCostHousingDBcontext.Add <ClientRegistration>(clientRegistration);
     lowCostHousingDBcontext.SaveChanges();
     return(RedirectToAction("Index"));
 }
 public Task <bool> RegisterClient(ClientRegistration registration, CancellationToken cancellationToken)
 {
     return(Task.FromResult(true));
 }
Beispiel #23
0
 public ClientRegisterOkCommand(ClientRegistration clientRegistration)
 {
     _clientRegistration = clientRegistration;
 }
Beispiel #24
0
 internal GitHub(bool?enabled, ClientRegistration registration, LoginScopes login)
 {
     Enabled      = enabled;
     Registration = registration;
     Login        = login;
 }
Beispiel #25
0
        private void button1_Click(object sender, EventArgs e)
        {
            ClientRegistration newRegister = new ClientRegistration(new RegistrationCore());

            newRegister.Show();
        }
        public ActionResult CompleteEntityProfile(ClientEntityCompleteProfileBinding model)
        {
            var userId = User.Identity.GetUserId();

            if (userId != model.UserID)
            {
                ModelState.AddModelError("", "Invalid user id provided");
            }
            if (ModelState.IsValid)
            {
                ClientRegistration clientRegistration = new ClientRegistration()
                {
                    ClientNumber = model.UserID,
                    Address      = model.line1 + " " + model.line2 + " " + model.line3 + " " + model.Suburb + " " + model.State + " " + model.Country + " " + model.PostCode,
                    EntityName   = model.EntityName,
                    EntityType   = model.EntityType,
                    ABN          = model.ABN,
                    ACN          = model.ACN,
                    Phone        = model.Phone,
                    Fax          = model.Fax
                };

                edisRopo.UpdateClientSync(clientRegistration);


                #region create risk profile if present
                if (model.riskProfile != null)
                {
                    var         riskProfile = model.riskProfile;
                    RiskProfile profile     = new RiskProfile {
                        CapitalLossAttitude    = riskProfile.capitalLossAttitude,
                        ClientID               = edisRopo.GetClientSync(model.UserID, DateTime.Now).Id,
                        Comments               = riskProfile.comments,
                        DateCreated            = DateTime.Now,
                        DateModified           = DateTime.Now,
                        IncomeSource           = riskProfile.incomeSource,
                        InvestmentKnowledge    = riskProfile.investmentKnowledge,
                        InvestmentObjective1   = riskProfile.investmentObjective1,
                        InvestmentObjective2   = riskProfile.investmentObjective2,
                        InvestmentObjective3   = riskProfile.investmentObjective3,
                        InvestmentProfile      = riskProfile.investmentProfile,
                        InvestmentTimeHorizon  = riskProfile.investmentTimeHorizon,
                        LongTermGoal1          = riskProfile.longTermGoal1,
                        LongTermGoal2          = riskProfile.longTermGoal2,
                        LongTermGoal3          = riskProfile.longTermGoal3,
                        MedTermGoal1           = riskProfile.medTermGoal1,
                        MedTermGoal2           = riskProfile.medTermGoal2,
                        MedTermGoal3           = riskProfile.medTermGoal3,
                        RetirementAge          = string.IsNullOrEmpty(riskProfile.retirementAge) ? (int?)null : Convert.ToInt32(riskProfile.retirementAge),
                        RetirementIncome       = riskProfile.retirementIncome,
                        RiskAttitude           = riskProfile.riskAttitude,
                        ShortTermAssetPercent  = riskProfile.shortTermAssetPercent,
                        ShortTermEquityPercent = riskProfile.shortTermEquityPercent,
                        ShortTermGoal1         = riskProfile.shortTermGoal1,
                        ShortTermGoal2         = riskProfile.shortTermGoal2,
                        ShortTermGoal3         = riskProfile.shortTermGoal3,
                        ShortTermTrading       = riskProfile.shortTermTrading,
                        //riskLevel = (int)RiskLevels.NotSet
                    };
                    if (edisRopo.getRiskProfileForClient(edisRopo.GetClientSync(model.UserID, DateTime.Now).Id) != null)
                    {
                        edisRopo.UpdateRiskProfile(profile);
                    }
                    else
                    {
                        edisRopo.CreateRiskProfileForClient(profile);
                    }
                }
                #endregion

                UserManager.RemoveFromRole(userId, AuthorizationRoles.Role_Preclient);
                UserManager.AddToRole(userId, AuthorizationRoles.Role_Client);

                //redirect to client dashboard here
                //return RedirectToAction("Index", "Client");
                //TempData["message"] = "Your profile has been successfully updated";
                //return JavaScript("document.location.replace('" + Url.Action("showMessage") + "');");
                return(JavaScript("document.location.replace('" + Url.Action("Index", "Client") + "');"));
            }
            else
            {
                return(PartialView(model));
            }
        }
			public override void onRegistrationCredentialsRequired(SinchClient client, ClientRegistration clientRegistration)
			{
			}
        public void Register(string connectionId, string token)
        {
            Logger.InfoFormat("Register ConnectionId={0}, Token={1}", connectionId, token);

            var parts = HttpTokenHelper.GetTokenParts(token);

            if (parts != null)
            {
                var registration = new ClientRegistration
                {
                    ConnectionId = connectionId,
                    Token = token,
                    SessionId = parts.SessionId,
                    UserName = parts.UserName,
                };

                if (RegisteredClients.TryAdd(token, registration))
                    Logger.DebugFormat("[ConnectionId={0}] Registered client {1}", registration.ConnectionId, registration);
                else
                    Logger.WarnFormat("[ConnectionId={0}] Failed to regsiter client {1}", registration.ConnectionId, registration);
            }
            else
            {
                Logger.WarnFormat("[ConnectionId={0}] Invalid token={1}", connectionId, token);
            }
        }
        private void ClientRegistrationButton_Click(object sender, RoutedEventArgs e)
        {
            ClientRegistration clientRegistrationWindow = new ClientRegistration();

            clientRegistrationWindow.Show();
        }
        public IHttpActionResult adviserCreateNewClient_Entity(EntityClientCreationBindingModel model)
        {
            if (model != null)          //ModelState.IsValid &&
            {
                using (EdisRepository edisRepo = new EdisRepository())
                {
                    #region create asp user and send email
                    var user = new ApplicationUser
                    {
                        Email       = model.email,
                        UserName    = model.email,
                        PhoneNumber = model.contactPhone
                    };
                    var password    = "******";//Membership.GeneratePassword(10, 0);
                    var userManager = Request.GetOwinContext().GetUserManager <ApplicationUserManager>();
                    userManager.Create(user, password);
                    userManager.AddToRole(user.Id, AuthorizationRoles.Role_Preclient);
                    //EmailUtilities.SendEmailToUser(user.Id, "", "", "");//send password
                    #endregion

                    #region create client profile
                    ClientRegistration client = new ClientRegistration
                    {
                        CreateOn     = DateTime.Now,
                        ClientNumber = user.Id,
                        EntityName   = model.nameOfEntity,
                        EntityType   = model.typeOfEntity,
                        ABN          = model.abn,
                        ACN          = model.acn,
                        Email        = model.email,
                        Phone        = model.contactPhone,
                        ClientType   = BusinessLayerParameters.clientType_entity,
                        GroupNumber  = model.existingGroupId
                    };

                    string code        = userManager.GenerateEmailConfirmationTokenAsync(user.Id).Result;
                    string path        = HttpContext.Current.Server.MapPath("~/EmailTemplate/ConfirmEmail.html");
                    var    Url         = new System.Web.Mvc.UrlHelper(HttpContext.Current.Request.RequestContext);
                    var    callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Current.Request.Url.Scheme);
                    string content     = System.IO.File.ReadAllText(path).Replace("###Name###", user.UserName).Replace("###Confirm###", callbackUrl);
                    userManager.SendEmailAsync(user.Id, "Confirm your account", content);


                    #endregion

                    #region insert both records to db

                    edisRepo.CreateNewClientSync(client);
                    #endregion

                    #region create risk profile if present
                    if (model.riskProfile != null)
                    {
                        var         riskProfile = model.riskProfile;
                        RiskProfile profile     = new RiskProfile {
                            CapitalLossAttitude    = riskProfile.capitalLossAttitude,
                            ClientID               = edisRepo.GetClientSync(user.Id, DateTime.Now).Id,
                            Comments               = riskProfile.comments,
                            DateCreated            = DateTime.Now,
                            DateModified           = DateTime.Now,
                            IncomeSource           = riskProfile.incomeSource,
                            InvestmentKnowledge    = riskProfile.investmentKnowledge,
                            InvestmentObjective1   = riskProfile.investmentObjective1,
                            InvestmentObjective2   = riskProfile.investmentObjective2,
                            InvestmentObjective3   = riskProfile.investmentObjective3,
                            InvestmentProfile      = riskProfile.investmentProfile,
                            InvestmentTimeHorizon  = riskProfile.investmentTimeHorizon,
                            LongTermGoal1          = riskProfile.longTermGoal1,
                            LongTermGoal2          = riskProfile.longTermGoal2,
                            LongTermGoal3          = riskProfile.longTermGoal3,
                            MedTermGoal1           = riskProfile.medTermGoal1,
                            MedTermGoal2           = riskProfile.medTermGoal2,
                            MedTermGoal3           = riskProfile.medTermGoal3,
                            RetirementAge          = string.IsNullOrEmpty(riskProfile.retirementAge) ? (int?)null : Convert.ToInt32(riskProfile.retirementAge),
                            RetirementIncome       = riskProfile.retirementIncome,
                            RiskAttitude           = riskProfile.riskAttitude,
                            ShortTermAssetPercent  = riskProfile.shortTermAssetPercent,
                            ShortTermEquityPercent = riskProfile.shortTermEquityPercent,
                            ShortTermGoal1         = riskProfile.shortTermGoal1,
                            ShortTermGoal2         = riskProfile.shortTermGoal2,
                            ShortTermGoal3         = riskProfile.shortTermGoal3,
                            ShortTermTrading       = riskProfile.shortTermTrading,
                            riskLevel              = Int32.Parse(riskProfile.riskLevel)
                        };
                        edisRepo.CreateRiskProfileForClient(profile);
                    }
                    #endregion

                    //#region save all changes and return ok

                    //db.SaveChanges();
                    return(Ok());
                    //#endregion
                }
            }
            else
            {
                return(BadRequest(ModelState));
            }
        }
Beispiel #31
0
 public override void onRegistrationCredentialsRequired(SinchClient client, ClientRegistration clientRegistration)
 {
 }
Beispiel #32
0
 public async Task CreateNewClient(ClientRegistration client)
 {
     await this._repository.CreateNewClient(client);
 }