/// <summary>
/// Initializes the SDK. This method must be called prior to any other method.
/// </summary>
/// <example>
/// This method should be called within
/// the <see cref="Application.OnLaunched(Windows.ApplicationModel.Activation.LaunchActivatedEventArgs)"/> method.
/// <code>
///
/// protected override void OnLaunched(LaunchActivatedEventArgs launchArgs)
/// {
/// MParticleOptions options = new MParticleOptions()
/// {
/// ApiKey = "REPLACE ME",
/// ApiSecret = "REPLACE ME",
/// LaunchArgs = launchArgs
/// };
///
/// MParticle.Start(options);
/// }
/// </code>
/// </example>
/// <param name="options">Required - at minimum you must supply an mParticle workspace key and secret.</param>
public static async Task <IdentityApiResult> StartAsync(MParticleOptions options)
{
if (instance == null)
{
lock (mutex)
{
if (instance == null)
{
instance = new MParticle(Application.Current, options);
instance.Application_Launched();
instance.Identity.IdentityStateChange += instance.Identity_IdentityStateChange;
}
}
var request = options.IdentifyRequest ?? IdentityApiRequest.WithUser(instance.Identity.CurrentUser).Build();
return(await instance.Identity.IdentifyAsync(request));
}
return(new IdentityApiResult()
{
Error = new ErrorResponse()
{
StatusCode = IdentityApi.UnknownError,
Errors = new Error[] {
new Error()
{
Message = "The SDK has already started."
}
}
}
});
}
private ModifyRequest BuildModifyRequest(MParticleUser user, IdentityApiRequest identityApiRequest)
{
var modifyRequest = new ModifyRequest()
{
IdentityChanges = new List <IdentityChange>()
};
PopulateBaseIdentityRequest(modifyRequest);
var updatedIdentities = identityApiRequest.UserIdentities;
var currentIdentities = user.UserIdentities;
foreach (var identity in updatedIdentities)
{
var change = new IdentityChange()
{
NewValue = identity.Value,
IdentityType = (IdentityType)identity.Key
};
if (currentIdentities.ContainsKey(identity.Key))
{
change.OldValue = currentIdentities[identity.Key];
}
(modifyRequest.IdentityChanges as List <IdentityChange>).Add(change);
}
return(modifyRequest);
}
public void TestEmptyBuild()
{
var requestBuilder = IdentityApiRequest.EmptyUser();
var request = requestBuilder.Build();
Assert.AreEqual(0, request.UserIdentities.Count);
}
public async Task <IdentityApiResult> IdentifyAsync(IdentityApiRequest identityApiRequest = null)
{
var request = BuildIdentityRequest(identityApiRequest);
var task = identityApiManager.Identify(request);
return(await PerformIdentityCallAsync(identityApiRequest, task));
}
public void TestSetUserAliasHandler()
{
var requestBuilder = IdentityApiRequest.EmptyUser();
var request = requestBuilder
.UserAliasDelegate((oldUser, newUser) => { }).Build();
Assert.IsNotNull(request.UserAliasDelegate);
}
private async Task <IdentityApiResult> PerformIdentityCallAsync(IdentityApiRequest originalRequest, Task <object> identityTask, MParticleUser user = null)
{
try
{
var response = await identityTask;
if (response is IdentityResponse)
{
var newUser = user ?? new MParticleUser(long.Parse(((IdentityResponse)response).Mpid), persistenceManager);
newUser.UserIdentities = originalRequest.UserIdentities;
if (CurrentUser == null || CurrentUser.Mpid != newUser.Mpid)
{
CurrentUser = newUser;
try
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
originalRequest.UserAliasDelegate?.Invoke(CurrentUser, newUser);
this.IdentityStateChange?.Invoke(this, new IdentityStateChangeEventArgs(originalRequest, newUser));
});
}
catch (Exception ex)
{
this.Logger?.Log(new LogEntry(LoggingEventType.Error, "Error while invoking IdentityStateChange listener" + ex.ToString()));
}
}
return(new IdentityApiResult()
{
User = newUser
});
}
else
{
return(new IdentityApiResult()
{
Error = (ErrorResponse)response
});
}
}
catch (Exception ex)
{
this.Logger?.Log(new LogEntry(LoggingEventType.Error, "Error while performing identity request: " + ex.ToString()));
return(new IdentityApiResult()
{
Error = new ErrorResponse()
{
StatusCode = (int)IdentityApi.UnknownError,
Errors = new Error[] { new Error()
{
Message = ex.Message
} }
}
});
}
}
internal static void AddUserIdentities(Identities identities, IdentityApiRequest identityApiRequest)
{
if (identityApiRequest != null)
{
var userIdentities = identityApiRequest.UserIdentities;
foreach (var identity in userIdentities)
{
identities[(IdentityType)identity.Key] = identity.Value;
}
}
}
private IdentityRequest BuildIdentityRequest(IdentityApiRequest identityApiRequest)
{
var identityRequest = new IdentityRequest();
PopulateBaseIdentityRequest(identityRequest);
var identities = new Identities();
AddDeviceIdentities(identities);
AddUserIdentities(identities, identityApiRequest);
identityRequest.KnownIdentities = identities;
return(identityRequest);
}
public void TestSetIdentities()
{
var requestBuilder = IdentityApiRequest.EmptyUser();
var request = requestBuilder
.Email("foo email")
.CustomerId("foo customer id")
.UserIdentity(Core.Dto.Events.UserIdentityType.Facebook, "foo facebook")
.Build();
Assert.AreEqual(3, request.UserIdentities.Count);
Assert.AreEqual("foo email", request.UserIdentities[Core.Dto.Events.UserIdentityType.Email]);
Assert.AreEqual("foo customer id", request.UserIdentities[Core.Dto.Events.UserIdentityType.CustomerId]);
Assert.AreEqual("foo facebook", request.UserIdentities[Core.Dto.Events.UserIdentityType.Facebook]);
}
public void TestAddUserIdentities()
{
var manager = new PersistenceManager(MParticleOptions.Builder("foo", "bar").Build());
manager.Initialize(new PackageVersion());
var identityApi = new IdentityApi("foo", "bar", manager);
var identities = new Identities();
Assert.AreEqual(0, identities.Count);
var apiRequest = IdentityApiRequest.EmptyUser()
.CustomerId("foo customer id")
.Email("foo email")
.UserIdentity(Core.Dto.Events.UserIdentityType.Google, "foo google")
.Build();
IdentityApi.AddUserIdentities(identities, apiRequest);
Assert.AreEqual(identities[IdentityType.CustomerId], "foo customer id");
Assert.AreEqual(identities[IdentityType.Email], "foo email");
Assert.AreEqual(identities[IdentityType.Google], "foo google");
}
internal async Task <IdentityApiResult> ModifyAsync(MParticleUser user, IdentityApiRequest identityApiRequest)
{
if (identityApiRequest == null || user == null)
{
return(new IdentityApiResult()
{
Error = new ErrorResponse()
{
StatusCode = (int)IdentityApi.BadRequest,
Errors = new Error [] { new Error()
{
Message = "Modify requests must not be empty."
} }
}
});
}
ModifyRequest request = BuildModifyRequest(user, identityApiRequest);
var task = identityApiManager.Modify(user.Mpid, request);
return(await PerformIdentityCallAsync(identityApiRequest, task, user));
}
/// <summary>
/// Set the initial Identify request to perform.
///
/// By default, the SDK will perform an Identify request for the last user of the device.
/// </summary>
/// <param name="identityApiRequest"></param>
/// <returns></returns>
public MParticleOptionsBuilder IdentifyRequest(IdentityApiRequest identityApiRequest)
{
this.identifyRequest = identityApiRequest;
return(this);
}
public async Task <IdentityApiResult> ModifyAsync(IdentityApiRequest identityApiRequest)
{
return(await MParticle.Instance.Identity.ModifyAsync(this, identityApiRequest));
}
internal IdentityStateChangeEventArgs(IdentityApiRequest request, MParticleUser user)
{
Request = request;
User = user;
}
