/// <summary>
/// Attempts to login with whatever account type is bound.
/// </summary>
public void Login(HttpRequest.RequestResult loginResult)
{
switch (AccountType)
{
case BoundAccountType.Rock:
{
LoggedIn = true;
loginResult(System.Net.HttpStatusCode.NoContent, "");
break;
}
case BoundAccountType.Facebook:
{
LoggedIn = true;
loginResult(System.Net.HttpStatusCode.NoContent, "");
break;
}
default:
{
throw new Exception("No account type bound, so I don't know how to log you in to Rock. Call Bind*Account first.");
}
}
}
public static void Get_GroupMembers(string oDataFilter, HttpRequest.RequestResult <List <Rock.Client.GroupMember> > requestHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_GroupMembers + oDataFilter;
Request.ExecuteAsync <List <Rock.Client.GroupMember> >(requestUrl, request, requestHandler);
}
public static void UpdateFullPerson(bool isNewPerson,
Rock.Client.Person person,
bool isNewPhoneNumber,
Rock.Client.PhoneNumber phoneNumber,
List <KeyValuePair <string, string> > attributes,
MemoryStream personImage,
HttpRequest.RequestResult resultHandler)
{
// first, we need to resolve their graduation year (if they have a valid grade offset set)
if (person.GradeOffset.HasValue && person.GradeOffset.Value >= 0)
{
RockApi.Get_People_GraduationYear(person.GradeOffset.Value,
delegate(HttpStatusCode statusCode, string statusDescription, int graduationYear)
{
// now set that and update the person
if (Rock.Mobile.Network.Util.StatusInSuccessRange(statusCode) == true)
{
person.GraduationYear = graduationYear;
TryUpdatePerson(isNewPerson, person, isNewPhoneNumber, phoneNumber, attributes, personImage, resultHandler);
}
else
{
// error
resultHandler(statusCode, statusDescription);
}
});
}
else
{
TryUpdatePerson(isNewPerson, person, isNewPhoneNumber, phoneNumber, attributes, personImage, resultHandler);
}
}
public static void Get_ContentChannelItems(string oDataFilter, HttpRequest.RequestResult <List <Rock.Client.ContentChannelItem> > resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_ContentChannelItems + oDataFilter;
Request.ExecuteAsync <List <Rock.Client.ContentChannelItem> >(requestUrl, request, resultHandler);
}
public static void Get_Groups <T>(string oDataFilter, HttpRequest.RequestResult <T> resultHandler) where T : new()
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_Groups + oDataFilter;
Request.ExecuteAsync <T>(requestUrl, request, resultHandler);
}
public static void Get_GetImage(string photoId, uint?width, uint?height, HttpRequest.RequestResult <MemoryStream> resultHandler)
{
// request a profile by the username. If no username is specified, we'll use the logged in user's name.
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + string.Format(EndPoint_GetImage, photoId);
// add the requested dimensions
if (width.HasValue)
{
requestUrl += string.Format("&width={0}", width);
}
// add the requested dimensions
if (height.HasValue)
{
requestUrl += string.Format("&height={0}", height);
}
// get the raw response
Request.ExecuteAsync(requestUrl, request, delegate(HttpStatusCode statusCode, string statusDescription, byte[] model)
{
if (model != null)
{
MemoryStream memoryStream = new MemoryStream(model);
resultHandler(statusCode, statusDescription, memoryStream);
memoryStream.Dispose( );
}
else
{
resultHandler(statusCode, statusDescription, null);
}
});
}
public void GetPersonData(HttpRequest.RequestResult onResult)
{
MobileAppApi.GetPersonData(UserID,
delegate(MobileAppApi.PersonData personData, HttpStatusCode statusCode)
{
if (personData != null)
{
// take the person (clear out the cell numbers since we manage those seperately)
Person = personData.Person;
Person.PhoneNumbers = null;
// search for a phone number (which should match whatever we already have, unless this is a new login)
if (personData.CellPhoneNumber != null)
{
_CellPhoneNumber = personData.CellPhoneNumber;
HasCellNumber = true;
}
else
{
// no longer has a phone number, so clear it
_CellPhoneNumber = new PhoneNumber( );
SetPhoneNumberDigits("");
HasCellNumber = false;
}
// we're always safe to take family--it cannot be null
PrimaryFamily = personData.Family;
// only take the address if it's valid. otherwise, we want
// to use the default, empty one.
if (personData.FamilyAddress != null)
{
PrimaryAddress = personData.FamilyAddress;
}
// set the person's current actions
IsBaptised = personData.IsBaptised;
IsERA = personData.IsERA;
IsGiving = personData.IsGiving;
TakenStartingPoint = personData.TakenStartingPoint;
IsMember = personData.IsMember;
IsServing = personData.IsServing;
IsPeerLearning = personData.IsPeerLearning;
IsMentored = personData.IsMentored;
IsTeaching = personData.IsTeaching;
// save!
SaveToDevice( );
}
if (onResult != null)
{
onResult(statusCode, "");
}
});
}
public void DisplayView(MobileAppApi.GroupSearchResult groupEntry, HttpRequest.RequestResult resultHandler)
{
// store the group and callback so that if it fails we can let them tap 'retry' and try again
GroupEntry = groupEntry;
GroupSummaryResult = resultHandler;
Internal_DisplayView( );
}
public static void Get_Groups_GuestsForFamily(int familyId, HttpRequest.RequestResult <List <Rock.Client.GuestFamily> > resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestString = BaseUrl + EndPoint_Groups_GuestsForFamily + familyId.ToString( );
Request.ExecuteAsync <List <Rock.Client.GuestFamily> >(requestString, request, resultHandler);
}
public static void Post_Groups_AttributeValue(string oDataFilter, HttpRequest.RequestResult resultHandler)
{
RestRequest request = GetRockRestRequest(Method.POST);
string requestString = BaseUrl + EndPoint_Groups_AttributeValue + oDataFilter;
Request.ExecuteAsync(requestString, request, resultHandler);
}
public static void Delete_People_AttributeValue(string oDataFilter, HttpRequest.RequestResult resultHandler)
{
RestRequest request = GetRockRestRequest(Method.DELETE);
string requestString = BaseUrl + EndPoint_People_AttributeValue + oDataFilter;
Request.ExecuteAsync(requestString, request, resultHandler);
}
public static void Post_Workflows_WorkflowEntry(string oDataFilter, HttpRequest.RequestResult resultHandler)
{
RestRequest request = GetRockRestRequest(Method.POST);
string requestString = EndPoint_Workflows_WorkflowEntry + oDataFilter;
Request.ExecuteAsync(BaseUrl + requestString, request, resultHandler);
}
public static void Get_DefinedTypes(string oDataFilter, HttpRequest.RequestResult <List <Rock.Client.DefinedType> > resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestString = BaseUrl + EndPoint_DefinedTypes + oDataFilter;
Request.ExecuteAsync <List <Rock.Client.DefinedType> >(requestString, request, resultHandler);
}
public static void Get_Groups_ByLocation(string oDataFilter, HttpRequest.RequestResult <List <Rock.Client.Group> > resultHandler)
{
// request a profile by the username. If no username is specified, we'll use the logged in user's name.
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_Groups_ByLocation + oDataFilter;
Request.ExecuteAsync <List <Rock.Client.Group> >(requestUrl, request, resultHandler);
}
public static void Post_Auth_FacebookLogin(object facebookUser, HttpRequest.RequestResult resultHandler)
{
RestRequest request = GetRockRestRequest(Method.POST);
request.AddBody(facebookUser);
Request.ExecuteAsync(BaseUrl + EndPoint_Auth_FacebookLogin, request, resultHandler);
}
public static void Get_GroupMembers_KnownRelationships(string query, HttpRequest.RequestResult <List <Rock.Client.GroupMember> > resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestString = BaseUrl + EndPoint_GroupMembers_KnownRelationships + query;
Request.ExecuteAsync <List <Rock.Client.GroupMember> >(requestString, request, resultHandler);
}
public static void Get_Categories_GetChildren_1(HttpRequest.RequestResult <List <Rock.Client.Category> > resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_Categories_GetChildren_1;
// get the resonse
Request.ExecuteAsync <List <Rock.Client.Category> >(requestUrl, request, resultHandler);
}
public static void Get_AttributeValues <T>(string oDataFilter, HttpRequest.RequestResult <T> resultHandler) where T : new()
{
// request a profile by the username. If no username is specified, we'll use the logged in user's name.
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_AttributeValues + oDataFilter;
Request.ExecuteAsync <T>(requestUrl, request, resultHandler);
}
public static void GetImpersonationToken(int personId, HttpRequest.RequestResult <string> resultHandler)
{
// with the resolved ID, get the impersonation token
RockApi.Get_People_GetSearchDetails(personId.ToString( ), delegate(HttpStatusCode statusCode, string statusDescription, string impersonationToken)
{
resultHandler(statusCode, statusDescription, impersonationToken);
});
}
public static void Get_Groups_GetFamily(int familyID, HttpRequest.RequestResult <Rock.Client.Family> resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestString = BaseUrl + string.Format(EndPoint_Groups_GetFamily, familyID);
Request.ExecuteAsync <Rock.Client.Family>(requestString, request, resultHandler);
}
static void TryUpdatePerson(bool isNewPerson,
Rock.Client.Person person,
bool isNewPhoneNumber,
Rock.Client.PhoneNumber phoneNumber,
List <KeyValuePair <string, string> > attributes,
MemoryStream personImage,
HttpRequest.RequestResult resultHandler)
{
// if they're a new person, flag them as a pending visitor.
if (isNewPerson == true)
{
person.RecordStatusValueId = Settings.Rock_RecordStatusValueId_Pending;
person.ConnectionStatusValueId = Settings.Rock_ConnectionStatusValueId_Visitor;
}
ApplicationApi.UpdateOrAddPerson(person, isNewPerson, Config.Instance.CurrentPersonAliasId,
delegate(System.Net.HttpStatusCode statusCode, string statusDescription)
{
if (Rock.Mobile.Network.Util.StatusInSuccessRange(statusCode) == true)
{
// was this a new person?
if (isNewPerson == true)
{
// then we need to get their profile so we know the ID to use for updating the rest of their stuff.
TryGetNewlyCreatedProfile(person, isNewPhoneNumber, phoneNumber, attributes, personImage, resultHandler);
}
else
{
// now update pending attributes.
foreach (KeyValuePair <string, string> attribValue in attributes)
{
// just fire and forget these values.
FamilyManagerApi.UpdateOrAddPersonAttribute(person.Id, attribValue.Key, attribValue.Value, null);
}
// are we deleting an existing number?
if (string.IsNullOrWhiteSpace(phoneNumber.Number) == true && isNewPhoneNumber == false)
{
TryDeleteCellPhone(person, phoneNumber, personImage, resultHandler);
}
// are we updating or adding an existing?
else if (string.IsNullOrWhiteSpace(phoneNumber.Number) == false)
{
TryUpdateCellPhone(person, isNewPhoneNumber, phoneNumber, personImage, resultHandler);
}
else
{
TryUpdateProfilePic(person, personImage, resultHandler);
}
}
}
else
{
// error
resultHandler(statusCode, statusDescription);
}
});
}
public void SyncRockData( SeriesDownloaded seriesCallback, HttpRequest.RequestResult resultCallback )
{
ResultCallback = resultCallback;
// have the launch data request the series before it does anything else.
RockLaunchData.Instance.GetNoteDB( delegate
{
seriesCallback( );
// if we're logged in, sync any changes we've made with the server.
if( RockMobileUser.Instance.LoggedIn == true )
{
Rock.Mobile.Util.Debug.WriteLine( "Logged in. Syncing out-of-sync data." );
//( this includes notes, profile changes, etc.)
RockMobileUser.Instance.TrySyncDirtyObjects(
delegate(System.Net.HttpStatusCode statusCode, string statusDescription)
{
// IF THERE WAS A PROBLEM SYNCING, DO NOT PULL DOWN THE LATEST PROFILE.
// That would cause pending changes to be lost.
if( Rock.Mobile.Network.Util.StatusInSuccessRange( statusCode ) == true )
{
Rock.Mobile.Util.Debug.WriteLine( "Syncing with server worked. Pulling down latest data." );
// now get their profile. Assuming there weren't any profile changes, this will download
// their latest profile. That way if someone made a change directly in Rock, it'll be reflected here.
RockMobileUser.Instance.GetProfileAndCellPhone( delegate
{
// get the address, which is certainly part
RockMobileUser.Instance.GetFamilyAndAddress( delegate
{
// and hey, why not their profile picture too
// if they have a profile picture, grab it.
RockMobileUser.Instance.TryDownloadProfilePicture( PrivateGeneralConfig.ProfileImageSize, delegate
{
// failure or not, server syncing is finished, so let's go ahead and
// get launch data.
RockLaunchData.Instance.GetLaunchData( LaunchDataReceived );
});
});
});
}
else
{
Rock.Mobile.Util.Debug.WriteLine( "Syncing with server FAILED. Skipping profile download to protect dirty data." );
// failure or not, server syncing is finished, so let's go ahead and
// get launch data.
RockLaunchData.Instance.GetLaunchData( LaunchDataReceived );
}
});
}
else
{
Rock.Mobile.Util.Debug.WriteLine( "Not Logged In. Skipping sync." );
RockLaunchData.Instance.GetLaunchData( LaunchDataReceived );
}
} );
}
public static void Get_Campuses(string queryString, HttpRequest.RequestResult <List <Rock.Client.Campus> > resultHandler)
{
// request a profile by the username. If no username is specified, we'll use the logged in user's name.
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_Campuses + queryString;
// get the raw response
Request.ExecuteAsync <List <Rock.Client.Campus> >(requestUrl, request, resultHandler);
}
public static void Delete_PhoneNumbers(int phoneNumberId, HttpRequest.RequestResult resultHandler)
{
RestRequest request = GetRockRestRequest(Method.DELETE);
string requestUrl = EndPoint_PhoneNumbers + phoneNumberId;
// fire off the request
Request.ExecuteAsync(BaseUrl + requestUrl, request, resultHandler);
}
public static void Get_People_ByUserName(string userName, HttpRequest.RequestResult <Rock.Client.Person> resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_People_GetByUserName;
requestUrl += userName;
Request.ExecuteAsync <Rock.Client.Person>(requestUrl, request, resultHandler);
}
public static void Post_Auth_Login(string username, string password, HttpRequest.RequestResult resultHandler)
{
RestRequest request = GetRockRestRequest(Method.POST);
request.AddParameter("Username", username);
request.AddParameter("Password", password);
request.AddParameter("Persisted", true);
Request.ExecuteAsync(BaseUrl + EndPoint_Auth_Login, request, resultHandler);
}
public static void CreateNewFamily(Rock.Client.Group groupModel, HttpRequest.RequestResult resultHandler)
{
// give the group model required values
groupModel.Guid = Guid.NewGuid( );
groupModel.GroupTypeId = FamilyGroupTypeId;
groupModel.IsActive = true;
groupModel.IsPublic = true;
RockApi.Post_Groups(groupModel, Config.Instance.CurrentPersonAliasId, resultHandler);
}
public static void Get_People_GraduationYear(int gradeOffset, HttpRequest.RequestResult <int> resultHandler)
{
RestRequest request = GetRockRestRequest(Method.GET);
string requestUrl = BaseUrl + EndPoint_People_GetGraduationYear;
requestUrl += gradeOffset;
Request.ExecuteAsync <int>(requestUrl, request, resultHandler);
}
public WebRequestObject(string requestUrl, RestRequest request, HttpRequest.RequestResult <TModel> callback, CookieContainer cookieContainer)
{
RequestUrl = requestUrl;
Request = request;
CookieContainer = cookieContainer;
ResultHandlers = new List <IResultHandler>( );
AttachResultHandler(new RequestResultObject <TModel>(callback));
}
public static void Get_PrayerRequests_Public(HttpRequest.RequestResult <List <Rock.Client.PrayerRequest> > resultHandler)
{
// request a profile by the username. If no username is specified, we'll use the logged in user's name.
RestRequest request = GetRockRestRequest(Method.GET);
// insert the expiration limit
string requestString = BaseUrl + EndPoint_PrayerRequests_Public;
Request.ExecuteAsync <List <Rock.Client.PrayerRequest> >(requestString, request, resultHandler);
}
public static void Login(string username, string password, HttpRequest.RequestResult resultHandler)
{
var loginObj = new
{
Username = username,
Password = password
};
RockApi.Post_CustomEndPoint(RockApi.BaseUrl + EndPoint_Login, loginObj, resultHandler);
}
