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;
}
