public static WorkspaceUserData Import(this WorkspaceUserJson json, IDataStoreContext ctx,
Guid?localIdHint = null, WorkspaceUserData mergeBase = null)
{
var converter = ServiceContainer.Resolve <WorkspaceUserJsonConverter> ();
return(converter.Import(ctx, json, localIdHint, mergeBase));
}
private static void ImportJson(IDataStoreContext ctx, WorkspaceUserData data, WorkspaceUserJson json)
{
var workspaceId = GetLocalId <WorkspaceData> (ctx, json.WorkspaceId);
var user = GetByRemoteId <UserData> (ctx, json.UserId, null);
// Update linked user data:
if (user == null)
{
user = new UserData()
{
RemoteId = json.UserId,
Name = json.Name,
Email = json.Email,
DefaultWorkspaceId = workspaceId,
ModifiedAt = DateTime.MinValue,
};
}
else
{
user.Name = json.Name;
user.Email = json.Email;
}
user = ctx.Put(user);
data.IsAdmin = json.IsAdmin;
data.IsActive = json.IsActive;
data.WorkspaceId = workspaceId;
data.UserId = user.Id;
ImportCommonJson(data, json);
}
public WorkspaceUserJson Export(IDataStoreContext ctx, WorkspaceUserData data)
{
var userRows = ctx.Connection.Table <UserData> ()
.Where(m => m.Id == data.UserId).Take(1).ToList();
if (userRows.Count == 0)
{
throw new InvalidOperationException(String.Format(
"Cannot export data with invalid local relation ({0}#{1}) to JSON.",
typeof(UserData).Name, data.UserId
));
}
var user = userRows [0];
if (user.RemoteId == null)
{
throw new RelationRemoteIdMissingException(typeof(UserData), data.UserId);
}
var workspaceId = GetRemoteId <WorkspaceData> (ctx, data.WorkspaceId);
return(new WorkspaceUserJson()
{
Id = data.RemoteId,
ModifiedAt = data.ModifiedAt.ToUtc(),
IsAdmin = data.IsAdmin,
IsActive = data.IsActive,
Name = user.Name,
Email = user.Email,
WorkspaceId = workspaceId,
UserId = user.RemoteId.Value,
});
}
public void ExportInvalidWorkspaceAndUser()
{
WorkspaceUserData workspaceUserData = null;
RunAsync(async delegate {
workspaceUserData = await DataStore.PutAsync(new WorkspaceUserData()
{
RemoteId = 4,
WorkspaceId = Guid.NewGuid(),
UserId = Guid.NewGuid(),
ModifiedAt = new DateTime(2014, 1, 3),
});
});
Assert.That(() => RunAsync(async delegate {
await DataStore.ExecuteInTransactionAsync(ctx => converter.Export(ctx, workspaceUserData));
}), Throws.Exception.TypeOf <InvalidOperationException> ());
}
private IEnumerable <ForeignRelation> GetWorkspaceUserRelations(WorkspaceUserData data)
{
yield return(new ForeignRelation()
{
Name = "WorkspaceId",
Type = typeof(WorkspaceData),
Required = true,
Id = data.WorkspaceId,
});
yield return(new ForeignRelation()
{
Name = "UserId",
Type = typeof(UserData),
Required = true,
Id = data.UserId,
});
}
public static WorkspaceUserJson Export(this WorkspaceUserData data, IDataStoreContext ctx)
{
var converter = ServiceContainer.Resolve <WorkspaceUserJsonConverter> ();
return(converter.Export(ctx, data));
}
private static async Task <DateTime> PullChanges(DateTime?lastRun)
{
var client = ServiceContainer.Resolve <ITogglClient> ();
var store = ServiceContainer.Resolve <IDataStore> ();
var log = ServiceContainer.Resolve <Logger> ();
if (lastRun == null)
{
log.Info(Tag, "Importing all user data from server.");
}
else
{
log.Info(Tag, "Importing changes from server (since {0}).", lastRun);
}
var changes = await client.GetChanges(lastRun).ConfigureAwait(false);
// Import data (in parallel batches)
var userData = await store.ExecuteInTransactionAsync(ctx => changes.User.Import(ctx));
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Workspaces)
{
var workspaceData = json.Import(ctx);
// Make sure that the user relation exists and is up to date
if (workspaceData != null)
{
var workspaceUserRows = ctx.Connection.Table <WorkspaceUserData> ()
.Where(r => r.WorkspaceId == workspaceData.Id && r.UserId == userData.Id && r.DeletedAt == null);
var workspaceUserData = workspaceUserRows.FirstOrDefault();
if (workspaceUserData == null)
{
workspaceUserData = new WorkspaceUserData()
{
WorkspaceId = workspaceData.Id,
UserId = userData.Id,
IsAdmin = json.IsAdmin,
};
}
else
{
workspaceUserData.IsAdmin = json.IsAdmin;
}
ctx.Put(workspaceUserData);
}
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Tags)
{
json.Import(ctx);
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Clients)
{
json.Import(ctx);
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Projects)
{
var projectData = json.Import(ctx);
// Make sure that the user relation exists
if (projectData != null)
{
var projectUserRows = ctx.Connection.Table <ProjectUserData> ()
.Where(r => r.ProjectId == projectData.Id && r.UserId == userData.Id && r.DeletedAt == null);
var projectUserData = projectUserRows.FirstOrDefault();
if (projectUserData == null)
{
projectUserData = new ProjectUserData()
{
ProjectId = projectData.Id,
UserId = userData.Id,
};
ctx.Put(projectUserData);
}
}
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Tasks)
{
json.Import(ctx);
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.TimeEntries)
{
json.Import(ctx);
}
});
return(changes.Timestamp);
}
public WorkspaceUserData Import(IDataStoreContext ctx, WorkspaceUserJson json, Guid?localIdHint = null, WorkspaceUserData mergeBase = null)
{
var log = ServiceContainer.Resolve <ILogger> ();
var data = GetByRemoteId <WorkspaceUserData> (ctx, json.Id.Value, localIdHint);
var merger = mergeBase != null ? new WorkspaceUserMerger(mergeBase) : null;
if (merger != null && data != null)
{
merger.Add(new WorkspaceUserData(data));
}
if (json.DeletedAt.HasValue)
{
if (data != null)
{
log.Info(Tag, "Deleting local data for {0}.", data.ToIdString());
ctx.Delete(data);
data = null;
}
}
else if (merger != null || ShouldOverwrite(data, json))
{
data = data ?? new WorkspaceUserData();
ImportJson(ctx, data, json);
if (merger != null)
{
merger.Add(data);
data = merger.Result;
}
if (merger != null)
{
log.Info(Tag, "Importing {0}, merging with local data.", data.ToIdString());
}
else
{
log.Info(Tag, "Importing {0}, replacing local data.", data.ToIdString());
}
data = ctx.Put(data);
}
else
{
log.Info(Tag, "Skipping import of {0}.", json.ToIdString());
}
return(data);
}
private static async Task <DateTime> PullChanges(DateTime?lastRun)
{
if (ServiceContainer.Resolve <AuthManager> ().OfflineMode)
{
return(DateTime.Now);
}
var client = ServiceContainer.Resolve <ITogglClient> ();
var store = ServiceContainer.Resolve <IDataStore> ();
var log = ServiceContainer.Resolve <ILogger> ();
if (lastRun == null)
{
log.Info(Tag, "Importing all user data from server.");
}
else
{
log.Info(Tag, "Importing changes from server (since {0}).", lastRun);
}
var changes = await client.GetChanges(lastRun).ConfigureAwait(false);
// TODO: OBM data that comes in user object from this changes
// is totally wrong. In that way, we should keep this info before
// before process the object.
var user = ServiceContainer.Resolve <AuthManager> ().User;
if (user != null)
{
changes.User.OBM.Included = user.ExperimentIncluded;
changes.User.OBM.Number = user.ExperimentNumber;
}
// Import data (in parallel batches)
var userData = await store.ExecuteInTransactionAsync(ctx => changes.User.Import(ctx));
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Workspaces)
{
var workspaceData = json.Import(ctx);
// Make sure that the user relation exists and is up to date
if (workspaceData != null)
{
var workspaceUserRows = ctx.Connection.Table <WorkspaceUserData> ()
.Where(r => r.WorkspaceId == workspaceData.Id && r.UserId == userData.Id && r.DeletedAt == null);
var workspaceUserData = workspaceUserRows.FirstOrDefault();
if (workspaceUserData == null)
{
workspaceUserData = new WorkspaceUserData()
{
WorkspaceId = workspaceData.Id,
UserId = userData.Id,
IsAdmin = json.IsAdmin,
};
}
else
{
workspaceUserData.IsAdmin = json.IsAdmin;
}
ctx.Put(workspaceUserData);
}
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Tags)
{
json.Import(ctx);
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Clients)
{
json.Import(ctx);
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Projects)
{
var projectData = json.Import(ctx);
// Make sure that the user relation exists
if (projectData != null)
{
var projectUserRows = ctx.Connection.Table <ProjectUserData> ()
.Where(r => r.ProjectId == projectData.Id && r.UserId == userData.Id && r.DeletedAt == null);
var projectUserData = projectUserRows.FirstOrDefault();
if (projectUserData == null)
{
projectUserData = new ProjectUserData()
{
ProjectId = projectData.Id,
UserId = userData.Id,
};
ctx.Put(projectUserData);
}
}
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.Tasks)
{
json.Import(ctx);
}
});
await store.ExecuteInTransactionAsync(ctx => {
foreach (var json in changes.TimeEntries)
{
json.Import(ctx);
}
});
return(changes.Timestamp);
}
