public BackendlessUser Register(BackendlessUser user) { CheckUserToBeProper(user, true); user.PutProperties(Invoker.InvokeSync <Dictionary <string, object> >(Invoker.Api.USERSERVICE_REGISTER, new object[] { user.Properties })); return(user); }
public ActionResult UserProfile(UserProfileModel userProfileModel) { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } if (ModelState.IsValid) { try { string loggedInUserName = (string)user.Properties["login"]; Backendless.UserService.Login(loggedInUserName, userProfileModel.OldPassword); user.Password = userProfileModel.NewPassword; user.SetProperty("name", userProfileModel.Name); user.SetProperty("surname", userProfileModel.Surname); user.SetProperty("email", userProfileModel.Email); Backendless.UserService.Update(user); ModelState.AddModelError("", "Zaktualizowano dane użytkownika."); } catch (BackendlessException exception) { if (exception.FaultCode == "3003") { ModelState.AddModelError("", "Błędne hasło użytkownika."); } else { ModelState.AddModelError("", exception.ToString()); } } } return(View(userProfileModel)); }
public LogInPage(BackendlessUser user) { InitializeComponent(); try { userInfo.Text = "ObjectId: " + user.ObjectId + "\nEmail: " + user.Email + "\n\nProperties:\n"; foreach (var entry in user.Properties) { if (entry.Key != "objectId" || entry.Key != "email") { userInfo.Text += "\t" + entry.Key + ": "; userInfo.Text += entry.Value + "\n"; } } Device.InvokeOnMainThreadAsync(() => { Content = loginLayout; }); } catch (Exception e) { Task.Run(async() => { await Device.InvokeOnMainThreadAsync(async() => { await DisplayAlert("Error", e.Message, "Ok"); }); }); } }
public void TestRestoreUserPassword() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomLoggedInUser(); Backendless.UserService.RestorePassword((string)user.GetProperty(LOGIN_KEY)); }
private AsyncCallback <Dictionary <string, object> > GetUserLoginAsyncHandler( AsyncCallback <BackendlessUser> callback) { return(new AsyncCallback <Dictionary <string, object> >(r => { HeadersManager.GetInstance() .AddHeader(HeadersEnum.USER_TOKEN_KEY, r[HeadersEnum.USER_TOKEN_KEY.Header].ToString()); if (CurrentUser == null) { CurrentUser = new BackendlessUser(); } CurrentUser.PutProperties(r); if (callback != null) { callback.ResponseHandler.Invoke(CurrentUser); } }, f => { if (callback != null) { callback.ErrorHandler.Invoke(f); } else { throw new BackendlessException(f); } })); }
public void TestRegisterNewUser() { RunAndAwait(() => { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomNotRegisteredUser(); string propertyKey = "property_key#" + Random.Next(); string propertyValue = "property_value#" + Random.Next(); user.SetProperty(propertyKey, propertyValue); Backendless.UserService.Register(user, new ResponseCallback <BackendlessUser>(this) { ResponseHandler = response => { UsedProperties.Add(propertyKey); Assert.IsNotNull(response.GetProperty("id"), "UserService.register didn't set user ID"); foreach (String key in user.Properties.Keys) { Assert.IsTrue(response.Properties.ContainsKey(key), "Registered user didn`t contain expected property " + key); Assert.AreEqual(user.GetProperty(key), response.GetProperty(key), "UserService.register changed property " + key); } CountDown(); } }); }); }
public void TestDescribeUserProperties() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomNotRegisteredUser(); string propertyKeySync = "property_key#Sync"; string propertyKeyAsync = "property_key#Async"; user.SetProperty(propertyKeySync, "porperty_value#" + Random.Next()); Backendless.UserService.Register(user); Backendless.UserService.Login((string)user.GetProperty(LOGIN_KEY), user.Password); List <UserProperty> userProperties = Backendless.UserService.DescribeUserClass(); Assert.IsNotNull(userProperties, "Server returned null user properties"); Assert.IsTrue(userProperties.Count != 0, "Server returned empty user properties"); var properties = new List <string> { propertyKeySync, propertyKeyAsync, ID_KEY, LOGIN_KEY, PASSWORD_KEY, EMAIL_KEY }; foreach (UserProperty userProperty in userProperties) { Assert.IsNotNull(userProperty, "User property was null"); Assert.IsTrue(properties.Contains(userProperty.Name), "User properties contained unexpected property " + userProperty.Name); Assert.IsNotNull(userProperty.Type, "User properties type was null"); } }
public CustomerDetailsForm(BackendlessUser user, Reservation r) { InitializeComponent(); //In the rare occurance that the user has deleted or deactivated his/her account if (user != null) { //Determines if the reservation was made by the restaurant if (user.ObjectId == OwnerStorage.ThisRestaurant.ownerId) { lblRestaurantLabel.Visible = true; lblTitle.Text = "Reservation details for " + r.Name; } //The reservation was made by a customer. His/her details will be displayed accordingly else { tbxContact.Text = user.GetProperty("Cellphone").ToString(); tbxFName.Text = user.GetProperty("FirstName").ToString(); tbxLName.Text = user.GetProperty("LastName").ToString(); tbxEmail.Text = user.GetProperty("email").ToString(); lblTitle.Text = "Reservation details for " + user.GetProperty("FirstName").ToString(); } } //Displays that the account could not be located else { lblRestaurantLabel.Visible = true; lblRestaurantLabel.Text = "This user has deactivated or deleted his/her account. No valid information about this user could be retrieved"; lblTitle.Text = "Reservation details for " + r.Name; } }
public void TestRegisterNewUserWithId() { RunAndAwait(() => { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); Backendless.UserService.Register(GetRandomNotRegisteredUser(), new ResponseCallback <BackendlessUser>(this) { ResponseHandler = response => { BackendlessUser fakeUser = GetRandomNotRegisteredUser(); fakeUser.SetProperty(ID_KEY, response.GetProperty(ID_KEY)); Backendless.UserService.Register(fakeUser, new ResponseCallback <BackendlessUser>( this) { ResponseHandler = user => FailCountDownWith( "Server accepted a user with id value"), ErrorHandler = fault => CheckErrorCode(3039, fault) }); } }); }); }
public ActionResult Register(RegisterModel registerModel) { if (ModelState.IsValid) { try { BackendlessUser newUser = new BackendlessUser(); newUser.SetProperty("login", registerModel.Login); newUser.SetProperty("email", registerModel.Email); newUser.SetProperty("name", registerModel.Name); newUser.SetProperty("surname", registerModel.Surname); newUser.Password = registerModel.Password; Backendless.UserService.Register(newUser); return(RedirectToAction("Login", "Account")); } catch (BackendlessException exception) { if (exception.FaultCode == "3033") { ModelState.AddModelError("", "Login jest zajęty."); } else { ModelState.AddModelError("", exception.ToString()); } } } return(View(registerModel)); }
public ActionResult TaskAdd(TaskModel taskModel) { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } if (ModelState.IsValid) { taskModel.TaskAuthor = (string)user.Properties["name"] + " " + (string)user.Properties["surname"]; taskModel.TaskCreateDate = DateTime.Now.Date; try { Backendless.Data.Save(taskModel); } catch (BackendlessException exception) { ModelState.AddModelError("", exception.ToString()); } ModelState.AddModelError("", "Zadanie zostało dodane."); return(RedirectToAction("Overview", "Application")); } return(View(taskModel)); }
private void LoadRelationsToEntity <T>(T entity, T response, IList <string> relations) { if (typeof(T).Equals(typeof(BackendlessUser))) { object source = entity; object updated = response; BackendlessUser userWithRelations = (BackendlessUser)updated; BackendlessUser sourceUser = (BackendlessUser)source; sourceUser.PutProperties(userWithRelations.Properties); } else { FieldInfo[] fields = typeof(T).GetFields(); foreach (var fieldInfo in fields) { if (relations.Contains(LOAD_ALL_RELATIONS) == false && relations.Contains(fieldInfo.Name) == false) { continue; } fieldInfo.SetValue(entity, fieldInfo.GetValue(response)); } PropertyInfo[] properties = typeof(T).GetProperties(); foreach (var propertyInfo in properties) { if (relations.Contains(LOAD_ALL_RELATIONS) == false && relations.Contains(propertyInfo.Name) == false) { continue; } propertyInfo.SetValue(entity, propertyInfo.GetValue(response, null), null); } } }
void Register() { mWaiting.SetActive(true); BackendlessUser user = new BackendlessUser(); user.Email = mEmail; user.Password = mPassword; user.AddProperty("name", mName); AsyncCallback <BackendlessUser> callback = new AsyncCallback <BackendlessUser>( savedUser => { mResultMessage = "Success\n\nThank you for registering!\nYou can use your email to login."; mIsRegisterFinish = true; mIsRegisterSuccess = true; }, fault => { mResultMessage = "Error\n\nCode = " + fault.FaultCode + "\nMessage = " + fault.Message; mIsRegisterFinish = true; mIsRegisterSuccess = false; }); Backendless.UserService.Register(user, callback); }
public void Logout(AsyncCallback <object> callback) { var responder = new AsyncCallback <object>(r => { CurrentUser = null; HeadersManager.GetInstance().RemoveHeader(HeadersEnum.USER_TOKEN_KEY); if (callback != null) { callback.ResponseHandler.Invoke(null); } }, f => { if (callback != null) { callback.ErrorHandler.Invoke(f); } else { throw new BackendlessException(f); } }); Invoker.InvokeAsync <object>(Invoker.Api.USERSERVICE_LOGOUT, null, responder); }
public void TestRestoreUserPassword() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION); BackendlessUser user = GetRandomRegisteredUser(); Backendless.UserService.RestorePassword((string)user.Email); }
public void Register( BackendlessUser user, AsyncCallback<BackendlessUser> callback ) { try { CheckUserToBeProper( user, true ); var responder = new AsyncCallback<Dictionary<string, object>>( r => { user.PutProperties( r ); if( callback != null ) callback.ResponseHandler.Invoke( user ); }, f => { if( callback != null ) callback.ErrorHandler.Invoke( f ); else throw new BackendlessException( f ); } ); Invoker.InvokeAsync<Dictionary<string, object>>( USER_MANAGER_SERVER_ALIAS, "register", new Object[] { Backendless.AppId, Backendless.VersionNum, user.Properties }, responder ); } catch( System.Exception ex ) { if( callback != null ) callback.ErrorHandler.Invoke( new BackendlessFault( ex.Message ) ); else throw; } }
public void TestCurrentUserAfterLogin() { try { BackendlessUser notRegisteredUseruser = GetRandomNotRegisteredUser(); string propertyKey = "propertykey" + Random.Next(); string propertyValue = "property_value#" + Random.Next(); notRegisteredUseruser.SetProperty(propertyKey, propertyValue); BackendlessUser user = Backendless.UserService.Register(notRegisteredUseruser); UsedProperties.Add(propertyKey); user = Backendless.UserService.Login((string)user.GetProperty(LOGIN_KEY), user.Password); Assert.IsNotNull(Backendless.UserService.CurrentUser, "Current user was null"); foreach (string key in user.Properties.Keys) { if (key.Equals("password")) { continue; } Assert.IsTrue(Backendless.UserService.CurrentUser.Properties.ContainsKey(key), "Current user didn`t contain expected property " + key); Assert.AreEqual(user.GetProperty(key), Backendless.UserService.CurrentUser.GetProperty(key), "UserService.register changed property " + key); } } catch (System.Exception t) { Assert.Fail(t.Message); } }
public BackendlessUser GetRandomLoggedInUser() { BackendlessUser user = GetRandomRegisteredUser(); Backendless.UserService.Login((string)user.Email, user.Password); return(user); }
public BackendlessUser Register(BackendlessUser user) { CheckUserToBeProper(user, true); user.PutProperties(Invoker.InvokeSync <Dictionary <string, object> >(USER_MANAGER_SERVER_ALIAS, "register", new Object[] { user.Properties })); return(user); }
public BackendlessUser GetRandomLoggedInUser() { BackendlessUser user = GetRandomRegisteredUser(); Backendless.UserService.Login((string)user.GetProperty(LOGIN_KEY), user.Password); return(user); }
public void TestUpdateRegisteredUserIdentity() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomLoggedInUser(); user.SetProperty(LOGIN_KEY, "some_new_login_" + user.GetProperty(LOGIN_KEY)); Backendless.UserService.Update(user); }
public void TestUserLogout() { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY); BackendlessUser user = GetRandomLoggedInUser(); Backendless.UserService.Logout(); Assert.IsTrue(Backendless.UserService.CurrentUser == null, "Current user was not empty"); }
public ActionResult TaskAdd() { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } return(View()); }
// GET: Application public ActionResult Overview(OverviewModel overviewModel) { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } return(View(overviewModel)); }
public BackendlessUser GetRandomNotRegisteredUser() { var timestamp = (DateTime.UtcNow.Ticks + Random.Next()).ToString(); BackendlessUser result = new BackendlessUser(); result.SetProperty( LOGIN_KEY, "bot" + timestamp ); result.SetProperty( EMAIL_KEY, result.GetProperty( LOGIN_KEY ) + "@gmail.com" ); result.Password = "******" + timestamp; return result; }
public ActionResult RemoveComment(string id) { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } comRepo.RemoveComment(id); return(RedirectToAction("Overview", "Application")); }
public BackendlessUser GetRandomNotRegisteredUser() { var timestamp = (DateTime.UtcNow.Ticks + Random.Next()).ToString(); var result = new BackendlessUser(); result.SetProperty(LOGIN_KEY, "bot" + timestamp); result.SetProperty(EMAIL_KEY, result.GetProperty(LOGIN_KEY) + "@gmail.com"); result.Password = "******" + timestamp; return(result); }
public void DefaultLoginTest() { BackendlessUser user = new BackendlessUser(); user.Email = "*****@*****.**"; user.Password = "******"; BackendlessUser responseUser = Backendless.UserService.Login(user.Email, user.Password, true); Assert.IsTrue(user.Email == responseUser.Email); Assert.IsTrue(Backendless.UserService.CurrentUser == responseUser); }
public OverviewModel() { BackendlessUser user = Backendless.UserService.CurrentUser; TaskRepository taskRepo = new TaskRepository(); ListOfAllTasks = taskRepo.GetListOfObjectsFromTable("TaskName LIKE '%'"); ListOfUserTasks = new List <TaskModel>(); foreach (var task in ListOfAllTasks) { TotalNumberOfTasks++; if (task.TaskStatus == "Otwarte") { NumberOfTasksWithStatusOpen++; } if (task.TaskStatus == "W Trakcie") { NumberOfTasksWithStatusInProgress++; } if (task.TaskStatus == "Przegląd Kodu") { NumberOfTasksWithStatusCodeReview++; } if (task.TaskStatus == "Zakończone") { NumberOfTasksWithStatusDone++; } if (task.TaskPriority == "Krytyczny") { NumberOfTasksWithPriorityCritical++; } if (task.TaskPriority == "Bardzo Wysoki") { NumberOfTasksWithPriorityVeryHigh++; } if (task.TaskPriority == "Wysoki") { NumberOfTasksWithPriorityHigh++; } if (task.TaskPriority == "Średni") { NumberOfTasksWithPriorityMedium++; } if (task.TaskPriority == "Niski") { NumberOfTasksWithPriorityLow++; } if (user != null && task.TaskAssignedToUser == (user.Properties["name"] + " " + user.Properties["surname"])) { NumberOfTasksAssignedToUser++; ListOfUserTasks.Add(task); } } }
private static void CheckUserToBeProper(BackendlessUser user, bool passwordCheck) { if (user == null) { throw new ArgumentNullException(ExceptionMessage.NULL_USER); } if (passwordCheck && string.IsNullOrEmpty(user.Password)) { throw new ArgumentNullException(ExceptionMessage.NULL_PASSWORD); } }
public ActionResult OverviewByPriority(string priority) { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } OverviewByPriority overviewByPriority = new OverviewByPriority(priority); return(View(overviewByPriority)); }
public ActionResult OverviewByStatus(string status) { BackendlessUser user = Backendless.UserService.CurrentUser; if (user == null) { return(RedirectToAction("Index", "Home")); } OverviewByStatus overviewByStatus = new OverviewByStatus(status); return(View(overviewByStatus)); }
public BackendlessUser Register( BackendlessUser user ) { CheckUserToBeProper( user, true ); user.PutProperties( Invoker.InvokeSync<Dictionary<string, object>>( USER_MANAGER_SERVER_ALIAS, "register", new Object[] { Backendless.AppId, Backendless.VersionNum, user.Properties } ) ); return user; }
public BackendlessUser Update( BackendlessUser user ) { CheckUserToBeProper( user, false ); if( string.IsNullOrEmpty( user.UserId ) ) throw new ArgumentNullException( ExceptionMessage.WRONG_USER_ID ); user.PutProperties( Invoker.InvokeSync<Dictionary<string, object>>( USER_MANAGER_SERVER_ALIAS, "update", new object[] { Backendless.AppId, Backendless.VersionNum, user.Properties } ) ); return user; }
public void TestRegisterNewUserWithNulls() { RunAndAwait( () => { Backendless.InitApp( Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION ); BackendlessUser user = new BackendlessUser(); user.SetProperty( LOGIN_KEY, null ); user.SetProperty( EMAIL_KEY, null ); user.Password = null; user.SetProperty( null, "foo" ); user.SetProperty( "foo", null ); Backendless.UserService.Register( user, new ResponseCallback<BackendlessUser>( this ) { ResponseHandler = response => FailCountDownWith( "UserService accepted null values" ) } ); } ); }
public void TestRegisterNewUserWithPartialFields() { try { Backendless.InitApp( Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, "v5" ); BackendlessUser partialUser = new BackendlessUser(); String login = "******" + Random.Next(); partialUser.SetProperty( LOGIN_KEY, login ); partialUser.SetProperty( EMAIL_KEY, login + "@gmail.com" ); partialUser.Password = "******"; Backendless.UserService.Register( partialUser ); Assert.Fail( "UserService accepted a user without required fields" ); } catch( System.Exception t ) { CheckErrorCode( 3012, t ); } }
public void TestRegisterNewUserWithNulls() { try { Backendless.InitApp(Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION); BackendlessUser user = new BackendlessUser(); user.SetProperty(LOGIN_KEY, null); user.SetProperty(EMAIL_KEY, null); user.Password = null; user.SetProperty(null, "foo"); user.SetProperty("foo", null); Backendless.UserService.Register(user); Assert.Fail("UserService accepted null values"); } catch( ArgumentNullException ) { } }
public void TestRegisterNewUserWithPartialFields() { RunAndAwait( () => { Backendless.InitApp( Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, "v5" ); BackendlessUser partialUser = new BackendlessUser(); String login = "******" + Random.Next(); partialUser.SetProperty( LOGIN_KEY, login ); partialUser.SetProperty( EMAIL_KEY, login + "@gmail.com" ); partialUser.Password = "******"; Backendless.UserService.Register( partialUser, new ResponseCallback<BackendlessUser>( this ) { ResponseHandler = response => FailCountDownWith( "UserService accepted a user without required fields" ), ErrorHandler = fault => CheckErrorCode( 3012, fault ) } ); } ); }
public void TestRegisterNewUserWithoutIdentity() { RunAndAwait( () => { Backendless.InitApp( Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION ); String timestamp = DateTime.Now.Ticks.ToString(); BackendlessUser user = new BackendlessUser(); user.SetProperty( EMAIL_KEY, "bot" + timestamp + "@gmail.com" ); user.Password = "******" + timestamp; Backendless.UserService.Register( user, new ResponseCallback<BackendlessUser>( this ) { ResponseHandler = response => FailCountDownWith( "Server accepted user without identity" ), ErrorHandler = fault => CheckErrorCode( 3013, fault ) } ); } ); }
private void HandleUserLogin(Dictionary<string, object> invokeResult) { HeadersManager.GetInstance() .AddHeader(HeadersEnum.USER_TOKEN_KEY, invokeResult[HeadersEnum.USER_TOKEN_KEY.Header].ToString()); if (CurrentUser == null) CurrentUser = new BackendlessUser(); CurrentUser.PutProperties(invokeResult); }
private AsyncCallback<Dictionary<string, object>> GetUserLoginAsyncHandler( AsyncCallback<BackendlessUser> callback) { return new AsyncCallback<Dictionary<string, object>>(r => { HeadersManager.GetInstance() .AddHeader(HeadersEnum.USER_TOKEN_KEY, r[HeadersEnum.USER_TOKEN_KEY.Header].ToString()); if (CurrentUser == null) CurrentUser = new BackendlessUser(); CurrentUser.PutProperties(r); if (callback != null) callback.ResponseHandler.Invoke(CurrentUser); }, f => { if (callback != null) callback.ErrorHandler.Invoke(f); else throw new BackendlessException(f); }); }
public void Logout() { try { Invoker.InvokeSync<object>( USER_MANAGER_SERVER_ALIAS, "logout", new object[] { Backendless.AppId, Backendless.VersionNum } ); } catch( BackendlessException exception ) { BackendlessFault fault = exception.BackendlessFault; if( fault != null ) { int faultCode = int.Parse( fault.FaultCode ); if( faultCode != 3064 && faultCode != 3091 && faultCode != 3090 && faultCode != 3023 ) throw exception; } } CurrentUser = null; HeadersManager.GetInstance().RemoveHeader( HeadersEnum.USER_TOKEN_KEY ); LoginStorage loginStorage = new LoginStorage(); loginStorage.DeleteFiles(); }
public void Update(BackendlessUser user, AsyncCallback<BackendlessUser> callback) { try { CheckUserToBeProper(user, false); if (string.IsNullOrEmpty(user.UserId)) throw new ArgumentNullException(ExceptionMessage.WRONG_USER_ID); var responder = new AsyncCallback<Dictionary<string, object>>(r => { user.PutProperties(r); if (callback != null) callback.ResponseHandler.Invoke(user); }, f => { if (callback != null) callback.ErrorHandler.Invoke(f); else throw new BackendlessException(f); }); Invoker.InvokeAsync<Dictionary<string, object>>(Invoker.Api.USERSERVICE_UPDATE, new object[] { user.Properties, user.UserId }, responder); } catch (System.Exception ex) { if (callback != null) callback.ErrorHandler.Invoke(new BackendlessFault(ex.Message)); else throw; } }
private void HandleUserLogin( Dictionary<string, object> invokeResult, bool stayLoggedIn ) { HeadersManager.GetInstance() .AddHeader( HeadersEnum.USER_TOKEN_KEY, invokeResult[ HeadersEnum.USER_TOKEN_KEY.Header ].ToString() ); if( CurrentUser == null ) CurrentUser = new BackendlessUser(); CurrentUser.PutProperties( invokeResult ); if( stayLoggedIn ) { LoginStorage loginStorage = new LoginStorage(); loginStorage.UserToken = invokeResult[ HeadersEnum.USER_TOKEN_KEY.Header ].ToString(); loginStorage.UserId = Backendless.UserService.CurrentUser.UserId; loginStorage.SaveData(); } }
public BackendlessUser Register(BackendlessUser user) { CheckUserToBeProper(user, true); user.PutProperties(Invoker.InvokeSync<Dictionary<string, object>>(Invoker.Api.USERSERVICE_REGISTER, new object[] { user.Properties })); return user; }
public void Logout(AsyncCallback<object> callback) { var responder = new AsyncCallback<object>(r => { CurrentUser = null; HeadersManager.GetInstance().RemoveHeader(HeadersEnum.USER_TOKEN_KEY); if (callback != null) callback.ResponseHandler.Invoke(null); }, f => { if (callback != null) callback.ErrorHandler.Invoke(f); else throw new BackendlessException(f); }); Invoker.InvokeAsync<object>(Invoker.Api.USERSERVICE_LOGOUT, null, responder); }
public void Logout() { try { Invoker.InvokeSync<object>(Invoker.Api.USERSERVICE_LOGOUT, null); } catch (BackendlessException exception) { BackendlessFault fault = exception.BackendlessFault; if (fault != null) { int faultCode = int.Parse(fault.FaultCode); if (faultCode != 3064 && faultCode != 3091 && faultCode != 3090 && faultCode != 3023) throw exception; } } CurrentUser = null; HeadersManager.GetInstance().RemoveHeader(HeadersEnum.USER_TOKEN_KEY); }
public void TestRegisterNewUserWithoutIdentity() { try { Backendless.InitApp( Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION ); String timestamp = DateTime.Now.Ticks.ToString(); BackendlessUser user = new BackendlessUser(); user.SetProperty( EMAIL_KEY, "bot" + timestamp + "@gmail.com" ); user.Password = "******" + timestamp; Backendless.UserService.Register( user ); Assert.Fail( "Server accepted user without identity" ); } catch( System.Exception t ) { CheckErrorCode( 3013, t ); } }
private static void CheckUserToBeProper(BackendlessUser user, bool passwordCheck) { if (user == null) throw new ArgumentNullException(ExceptionMessage.NULL_USER); if (passwordCheck && string.IsNullOrEmpty(user.Password)) throw new ArgumentNullException(ExceptionMessage.NULL_PASSWORD); }
public void Register(BackendlessUser user, AsyncCallback<BackendlessUser> callback) { try { CheckUserToBeProper(user, true); var responder = new AsyncCallback<Dictionary<string, object>>(r => { user.PutProperties(r); if (callback != null) callback.ResponseHandler.Invoke(user); }, f => { if (callback != null) callback.ErrorHandler.Invoke(f); else throw new BackendlessException(f); }); Invoker.InvokeAsync<Dictionary<string, object>>(Invoker.Api.USERSERVICE_REGISTER, new object[] { user.Properties }, responder); } catch (System.Exception ex) { if (callback != null) callback.ErrorHandler.Invoke(new BackendlessFault(ex.Message)); else throw; } }
public void Logout( AsyncCallback<object> callback ) { var responder = new AsyncCallback<object>( r => { CurrentUser = null; HeadersManager.GetInstance().RemoveHeader( HeadersEnum.USER_TOKEN_KEY ); LoginStorage loginStorage = new LoginStorage(); loginStorage.DeleteFiles(); if( callback != null ) callback.ResponseHandler.Invoke( null ); }, f => { if( callback != null ) callback.ErrorHandler.Invoke( f ); else throw new BackendlessException( f ); } ); Invoker.InvokeAsync( USER_MANAGER_SERVER_ALIAS, "logout", new object[] { Backendless.AppId, Backendless.VersionNum }, responder ); }
public void TestRegisterNewUserWithEmptyCredentials() { RunAndAwait( () => { Backendless.InitApp( Defaults.TEST_APP_ID, Defaults.TEST_SECRET_KEY, Defaults.TEST_VERSION ); BackendlessUser user = new BackendlessUser(); user.SetProperty( LOGIN_KEY, "" ); user.SetProperty( EMAIL_KEY, "" ); user.Password = ""; user.SetProperty( "", "foo" ); user.SetProperty( "foo", "" ); Backendless.UserService.Register( user, new ResponseCallback<BackendlessUser>( this ) { ResponseHandler = response => FailCountDownWith( "BackendlessUser accepted empty values" ), ErrorHandler = fault => { Assert.IsTrue(fault.ToString().Contains("Value cannot be null")); CountDown(); } } ); } ); }
public BackendlessUser Update(BackendlessUser user) { CheckUserToBeProper(user, false); if (string.IsNullOrEmpty(user.UserId)) throw new ArgumentNullException(ExceptionMessage.WRONG_USER_ID); user.PutProperties(Invoker.InvokeSync<Dictionary<string, object>>(Invoker.Api.USERSERVICE_UPDATE, new object[] { user.Properties, user.UserId })); return user; }