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 WorkspaceUserData Import (IDataStoreContext ctx, WorkspaceUserJson json, Guid? localIdHint = null, WorkspaceUserData mergeBase = null)
        {
            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) {
                    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;
                }

                data = ctx.Put (data);
            }

            return data;
        }
Exemple #3
0
        public void ImportPastDeleted()
        {
            RunAsync(async delegate {
                var workspaceData = await DataStore.PutAsync(new WorkspaceData()
                {
                    RemoteId   = 1,
                    ModifiedAt = new DateTime(2014, 1, 2),
                });
                var userData = await DataStore.PutAsync(new UserData()
                {
                    RemoteId   = 2,
                    ModifiedAt = new DateTime(2014, 1, 3),
                });
                var workspaceUserData = await DataStore.PutAsync(new WorkspaceUserData()
                {
                    RemoteId    = 2,
                    WorkspaceId = workspaceData.Id,
                    UserId      = userData.Id,
                    ModifiedAt  = new DateTime(2014, 1, 3),
                });

                var workspaceUserJson = new WorkspaceUserJson()
                {
                    Id        = 2,
                    DeletedAt = new DateTime(2014, 1, 2),
                };

                var ret = await DataStore.ExecuteInTransactionAsync(ctx => converter.Import(ctx, workspaceUserJson));
                Assert.IsNull(ret);

                var rows = await DataStore.Table <WorkspaceUserData> ().QueryAsync(m => m.Id == workspaceUserData.Id);
                Assert.That(rows, Has.Exactly(0).Count);
            });
        }
Exemple #4
0
        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));
        }
Exemple #5
0
        public void ImportMissingWorkspaceAndUser()
        {
            RunAsync(async delegate {
                var workspaceUserJson = new WorkspaceUserJson()
                {
                    Id          = 2,
                    WorkspaceId = 1,
                    UserId      = 2,
                    ModifiedAt  = new DateTime(2014, 1, 3),
                };

                var workspaceUserData = await DataStore.ExecuteInTransactionAsync(ctx => converter.Import(ctx, workspaceUserJson));
                Assert.AreNotEqual(Guid.Empty, workspaceUserData.WorkspaceId);
                Assert.AreNotEqual(Guid.Empty, workspaceUserData.UserId);

                var projectRows   = await DataStore.Table <WorkspaceData> ().QueryAsync(m => m.Id == workspaceUserData.WorkspaceId);
                var workspaceData = projectRows.FirstOrDefault();
                Assert.IsNotNull(workspaceData);
                Assert.IsNotNull(workspaceData.RemoteId);
                Assert.AreEqual(DateTime.MinValue, workspaceData.ModifiedAt);

                var userRows = await DataStore.Table <UserData> ().QueryAsync(m => m.Id == workspaceUserData.UserId);
                var userData = userRows.FirstOrDefault();
                Assert.IsNotNull(userData);
                Assert.IsNotNull(userData.RemoteId);
                Assert.AreEqual(DateTime.MinValue, userData.ModifiedAt);
            });
        }
Exemple #6
0
        public void ImportUpdatedKeepDirtyLocal()
        {
            RunAsync(async delegate {
                var workspaceData = await DataStore.PutAsync(new WorkspaceData()
                {
                    RemoteId   = 1,
                    ModifiedAt = new DateTime(2014, 1, 2),
                });
                var userData = await DataStore.PutAsync(new UserData()
                {
                    RemoteId   = 2,
                    ModifiedAt = new DateTime(2014, 1, 3),
                });
                var workspaceUserData = await DataStore.PutAsync(new WorkspaceUserData()
                {
                    RemoteId    = 2,
                    WorkspaceId = Guid.Empty,
                    UserId      = Guid.Empty,
                    ModifiedAt  = new DateTime(2014, 1, 2, 10, 0, 0, DateTimeKind.Utc),
                    IsDirty     = true,
                });
                var workspaceUserJson = new WorkspaceUserJson()
                {
                    Id          = 2,
                    WorkspaceId = 1,
                    UserId      = 2,
                    ModifiedAt  = new DateTime(2014, 1, 2, 10, 0, 0, DateTimeKind.Utc).ToLocalTime(),
                };

                workspaceUserData = await DataStore.ExecuteInTransactionAsync(ctx => converter.Import(ctx, workspaceUserJson));
                Assert.AreEqual(Guid.Empty, workspaceUserData.WorkspaceId);
                Assert.AreEqual(new DateTime(2014, 1, 2, 10, 0, 0, DateTimeKind.Utc), workspaceUserData.ModifiedAt);
            });
        }
Exemple #7
0
        public void ImportNew()
        {
            RunAsync(async delegate {
                var workspaceData = await DataStore.PutAsync(new WorkspaceData()
                {
                    RemoteId   = 1,
                    ModifiedAt = new DateTime(2014, 1, 2),
                });
                var userData = await DataStore.PutAsync(new UserData()
                {
                    RemoteId   = 2,
                    ModifiedAt = new DateTime(2014, 1, 3),
                });
                var workspaceUserJson = new WorkspaceUserJson()
                {
                    Id          = 2,
                    WorkspaceId = 1,
                    UserId      = 2,
                    ModifiedAt  = new DateTime(2014, 1, 3),
                };

                var workspaceUserData = await DataStore.ExecuteInTransactionAsync(ctx => converter.Import(ctx, workspaceUserJson));
                Assert.AreNotEqual(Guid.Empty, workspaceUserData.Id);
                Assert.AreEqual(2, workspaceUserData.RemoteId);
                Assert.AreEqual(new DateTime(2014, 1, 3), workspaceUserData.ModifiedAt);
                Assert.AreEqual(workspaceData.Id, workspaceUserData.WorkspaceId);
                Assert.AreEqual(userData.Id, workspaceUserData.UserId);
                Assert.IsFalse(workspaceUserData.IsDirty);
                Assert.IsFalse(workspaceUserData.RemoteRejected);
                Assert.IsNull(workspaceUserData.DeletedAt);
            });
        }
        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);
        }
        public WorkspaceUserData Import (IDataStoreContext ctx, WorkspaceUserJson json, Guid? localIdHint = null, bool forceUpdate = false)
        {
            var data = GetByRemoteId<WorkspaceUserData> (ctx, json.Id.Value, localIdHint);

            if (json.DeletedAt.HasValue) {
                if (data != null) {
                    ctx.Delete (data);
                    data = null;
                }
            } else if (data == null || forceUpdate || data.ModifiedAt < json.ModifiedAt) {
                data = data ?? new WorkspaceUserData ();
                Merge (ctx, data, json);
                data = ctx.Put (data);
            }

            return data;
        }
Exemple #10
0
        public void ImportUpdated()
        {
            RunAsync(async delegate {
                var workspaceData = await DataStore.PutAsync(new WorkspaceData()
                {
                    RemoteId   = 1,
                    ModifiedAt = new DateTime(2014, 1, 2),
                });
                var userData = await DataStore.PutAsync(new UserData()
                {
                    RemoteId   = 2,
                    ModifiedAt = new DateTime(2014, 1, 3),
                });
                var workspaceUserData = await DataStore.PutAsync(new WorkspaceUserData()
                {
                    RemoteId    = 2,
                    WorkspaceId = Guid.Empty,
                    UserId      = Guid.Empty,
                    ModifiedAt  = new DateTime(2014, 1, 2, 10, 0, 0, DateTimeKind.Utc),
                });
                var workspaceUserJson = new WorkspaceUserJson()
                {
                    Id          = 2,
                    WorkspaceId = 1,
                    UserId      = 2,
                    ModifiedAt  = new DateTime(2014, 1, 2, 10, 1, 0, DateTimeKind.Utc).ToLocalTime(),  // JSON deserialized to local
                };

                workspaceUserData = await DataStore.ExecuteInTransactionAsync(ctx => converter.Import(ctx, workspaceUserJson));
                Assert.AreNotEqual(Guid.Empty, workspaceUserData.Id);
                Assert.AreEqual(2, workspaceUserData.RemoteId);
                Assert.AreEqual(new DateTime(2014, 1, 2, 10, 1, 0, DateTimeKind.Utc), workspaceUserData.ModifiedAt);
                Assert.AreEqual(workspaceData.Id, workspaceUserData.WorkspaceId);
                Assert.AreEqual(userData.Id, workspaceUserData.UserId);
                Assert.IsFalse(workspaceUserData.IsDirty);
                Assert.IsFalse(workspaceUserData.RemoteRejected);
                Assert.IsNull(workspaceUserData.DeletedAt);
            });

            // Warn the user that the test result might be invalid
            if (TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now).TotalMinutes >= 0)
            {
                Assert.Inconclusive("The test machine timezone should be set to GTM-1 or less to test datetime comparison.");
            }
        }
Exemple #11
0
        public async Task<WorkspaceUserJson> CreateWorkspaceUser (WorkspaceUserJson jsonObject)
        {
            var url = new Uri (v8Url, String.Format ("workspaces/{0}/invite", jsonObject.WorkspaceId.ToString ()));

            var json = JsonConvert.SerializeObject (new {
                emails = new string[] { jsonObject.Email },
            });
            var httpReq = SetupRequest (new HttpRequestMessage () {
                Method = HttpMethod.Post,
                RequestUri = url,
                Content = new StringContent (json, Encoding.UTF8, "application/json"),
            });
            var httpResp = await SendAsync (httpReq)
                           .ConfigureAwait (continueOnCapturedContext: false);

            var wrap = JObject.Parse (await httpResp.Content.ReadAsStringAsync ()
                                      .ConfigureAwait (continueOnCapturedContext: false));
            var data = wrap ["data"] [0].ToObject<WorkspaceUserJson> ();
            return data;
        }
        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;
        }
        public Task DeleteWorkspaceUser(WorkspaceUserJson jsonObject)
        {
            var url = new Uri(v8Url, String.Format("workspace_users/{0}", jsonObject.Id.Value.ToString()));

            return(DeleteObject(url));
        }
        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);
        }