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 static CommonData Import (this CommonJson json, IDataStoreContext ctx,
                                  Guid? localIdHint = null, CommonData mergeBase = null)
 {
     var type = json.GetType ();
     if (type == typeof (ClientJson)) {
         return Import ((ClientJson)json, ctx, localIdHint, (ClientData)mergeBase);
     } else if (type == typeof (ProjectJson)) {
         return Import ((ProjectJson)json, ctx, localIdHint, (ProjectData)mergeBase);
     } else if (type == typeof (ProjectUserJson)) {
         return Import ((ProjectUserJson)json, ctx, localIdHint, (ProjectUserData)mergeBase);
     } else if (type == typeof (TagJson)) {
         return Import ((TagJson)json, ctx, localIdHint, (TagData)mergeBase);
     } else if (type == typeof (TaskJson)) {
         return Import ((TaskJson)json, ctx, localIdHint, (TaskData)mergeBase);
     } else if (type == typeof (TimeEntryJson)) {
         return Import ((TimeEntryJson)json, ctx, localIdHint, (TimeEntryData)mergeBase);
     } else if (type == typeof (UserJson)) {
         return Import ((UserJson)json, ctx, localIdHint, (UserData)mergeBase);
     } else if (type == typeof (WorkspaceJson)) {
         return Import ((WorkspaceJson)json, ctx, localIdHint, (WorkspaceData)mergeBase);
     } else if (type == typeof (WorkspaceUserJson)) {
         return Import ((WorkspaceUserJson)json, ctx, localIdHint, (WorkspaceUserData)mergeBase);
     }
     throw new InvalidOperationException (String.Format ("Unknown type of {0}", type));
 }

        public WorkspaceUserJson Export (IDataStoreContext ctx, WorkspaceUserData data)
        {
            var userRows = ctx.Connection.Table<UserData> ()
                .Take (1).Where (m => m.Id == data.UserId).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,
            };
        }

 private List<string> GetTimeEntryTags (IDataStoreContext ctx, Guid id)
 {
     if (id == Guid.Empty) {
         return new List<string> (0);
     }
     return ctx.GetTimeEntryTagNames (id);
 }

        public ClientData Import (IDataStoreContext ctx, ClientJson json, Guid? localIdHint = null, ClientData mergeBase = null)
        {
            var data = GetByRemoteId<ClientData> (ctx, json.Id.Value, localIdHint);

            var merger = mergeBase != null ? new ClientMerger (mergeBase) : null;
            if (merger != null && data != null)
                merger.Add (new ClientData (data));

            if (json.DeletedAt.HasValue) {
                if (data != null) {
                    ctx.Delete (data);
                    data = null;
                }
            } else if (merger != null || ShouldOverwrite (data, json)) {
                data = data ?? new ClientData ();
                ImportJson (ctx, data, json);

                if (merger != null) {
                    merger.Add (data);
                    data = merger.Result;
                }

                data = ctx.Put (data);
            }

            return data;
        }

        public ClientJson Export (IDataStoreContext ctx, ClientData data)
        {
            var workspaceId = GetRemoteId<WorkspaceData> (ctx, data.WorkspaceId);

            return new ClientJson () {
                Id = data.RemoteId,
                ModifiedAt = data.ModifiedAt.ToUtc (),
                Name = data.Name,
                WorkspaceId = workspaceId,
            };
        }

        private static void ImportJson (IDataStoreContext ctx, ProjectUserData data, ProjectUserJson json)
        {
            var projectId = GetLocalId<ProjectData> (ctx, json.ProjectId);
            var userId = GetLocalId<UserData> (ctx, json.UserId);

            data.HourlyRate = json.HourlyRate;
            data.IsManager = json.IsManager;
            data.ProjectId = projectId;
            data.UserId = userId;

            ImportCommonJson (data, json);
        }

        private static void Merge (IDataStoreContext ctx, TaskData data, TaskJson json)
        {
            var projectId = GetLocalId<ProjectData> (ctx, json.ProjectId);
            var workspaceId = GetLocalId<WorkspaceData> (ctx, json.WorkspaceId);

            data.Name = json.Name;
            data.IsActive = json.IsActive;
            data.Estimate = json.Estimate;
            data.ProjectId = projectId;
            data.WorkspaceId = workspaceId;

            MergeCommon (data, json);
        }

        public ProjectUserJson Export (IDataStoreContext ctx, ProjectUserData data)
        {
            var projectId = GetRemoteId<ProjectData> (ctx, data.ProjectId);
            var userId = GetRemoteId<UserData> (ctx, data.UserId);

            return new ProjectUserJson () {
                Id = data.RemoteId,
                ModifiedAt = data.ModifiedAt.ToUtc (),
                HourlyRate = data.HourlyRate,
                IsManager = data.IsManager,
                ProjectId = projectId,
                UserId = userId,
            };
        }

        public TaskJson Export (IDataStoreContext ctx, TaskData data)
        {
            var projectId = GetRemoteId<ProjectData> (ctx, data.ProjectId);
            var workspaceId = GetRemoteId<WorkspaceData> (ctx, data.WorkspaceId);

            return new TaskJson () {
                Id = data.RemoteId,
                ModifiedAt = data.ModifiedAt.ToUtc (),
                Name = data.Name,
                IsActive = data.IsActive,
                Estimate = data.Estimate,
                ProjectId = projectId,
                WorkspaceId = workspaceId,
            };
        }

 public WorkspaceJson Export (IDataStoreContext ctx, WorkspaceData data)
 {
     return new WorkspaceJson () {
         Id = data.RemoteId,
         ModifiedAt = data.ModifiedAt.ToUtc (),
         Name = data.Name,
         IsPremium = data.IsPremium,
         DefaultRate = data.DefaultRate,
         DefaultCurrency = data.DefaultCurrency,
         OnlyAdminsMayCreateProjects = data.ProjectCreationPrivileges == AccessLevel.Admin,
         OnlyAdminsSeeBillableRates = data.BillableRatesVisibility == AccessLevel.Admin,
         RoundingMode = data.RoundingMode,
         RoundingPercision = data.RoundingPercision,
         LogoUrl = data.LogoUrl,
     };
 }

        public TagData Import (IDataStoreContext ctx, TagJson json, Guid? localIdHint = null, bool forceUpdate = false)
        {
            var data = GetByRemoteId<TagData> (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 = Merge (ctx, data, json);
                data = ctx.Put (data);
            }

            return data;
        }

        private static void ImportJson (IDataStoreContext ctx, UserData data, UserJson json)
        {
            var defaultWorkspaceId = GetLocalId<WorkspaceData> (ctx, json.DefaultWorkspaceId);

            data.Name = json.Name;
            data.Email = json.Email;
            data.StartOfWeek = json.StartOfWeek;
            data.DateFormat = json.DateFormat;
            data.TimeFormat = json.TimeFormat;
            data.ImageUrl = json.ImageUrl;
            data.Locale = json.Locale;
            data.Timezone = json.Timezone;
            data.SendProductEmails = json.SendProductEmails;
            data.SendTimerNotifications = json.SendTimerNotifications;
            data.SendWeeklyReport = json.SendWeeklyReport;
            data.TrackingMode = json.StoreStartAndStopTime ? TrackingMode.StartNew : TrackingMode.Continue;
            data.DefaultWorkspaceId = defaultWorkspaceId;

            ImportCommonJson (data, json);
        }

        private static TagData ImportJson (IDataStoreContext ctx, TagData data, TagJson json)
        {
            var workspaceId = GetLocalId<WorkspaceData> (ctx, json.WorkspaceId);

            if (data == null) {
                // Fallback to name lookup for unsynced tags:
                var rows = ctx.Connection.Table<TagData> ().Take (1)
                    .Where (r => r.WorkspaceId == workspaceId && r.Name == json.Name && r.RemoteId == null);
                data = rows.FirstOrDefault ();
            }

            // As a last chance create new tag:
            data = data ?? new TagData ();

            data.Name = json.Name;
            data.WorkspaceId = workspaceId;

            ImportCommonJson (data, json);

            return data;
        }

        public ClientData Import (IDataStoreContext ctx, ClientJson json, Guid? localIdHint = null, ClientData mergeBase = null)
        {
            var log = ServiceContainer.Resolve<ILogger> ();

            var data = GetByRemoteId<ClientData> (ctx, json.Id.Value, localIdHint);

            var merger = mergeBase != null ? new ClientMerger (mergeBase) : null;
            if (merger != null && data != null) {
                merger.Add (new ClientData (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 ClientData ();
                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 UserJson Export (IDataStoreContext ctx, UserData data)
        {
            var defaultWorkspaceId = GetRemoteId<WorkspaceData> (ctx, data.DefaultWorkspaceId);

            return new UserJson () {
                Id = data.RemoteId,
                ModifiedAt = data.ModifiedAt.ToUtc (),
                Name = data.Name,
                Email = data.Email,
                StartOfWeek = data.StartOfWeek,
                DateFormat = data.DateFormat,
                TimeFormat = data.TimeFormat,
                ImageUrl = data.ImageUrl,
                Locale = data.Locale,
                Timezone = data.Timezone,
                SendProductEmails = data.SendProductEmails,
                SendTimerNotifications = data.SendTimerNotifications,
                SendWeeklyReport = data.SendWeeklyReport,
                StoreStartAndStopTime = data.TrackingMode == TrackingMode.StartNew,
                DefaultWorkspaceId = defaultWorkspaceId,
            };
        }

 public static CommonJson Export (this CommonData data, IDataStoreContext ctx)
 {
     var type = data.GetType ();
     if (type == typeof (ClientData)) {
         return Export ((ClientData)data, ctx);
     } else if (type == typeof (ProjectData)) {
         return Export ((ProjectData)data, ctx);
     } else if (type == typeof (ProjectUserData)) {
         return Export ((ProjectUserData)data, ctx);
     } else if (type == typeof (TagData)) {
         return Export ((TagData)data, ctx);
     } else if (type == typeof (TaskData)) {
         return Export ((TaskData)data, ctx);
     } else if (type == typeof (TimeEntryData)) {
         return Export ((TimeEntryData)data, ctx);
     } else if (type == typeof (UserData)) {
         return Export ((UserData)data, ctx);
     } else if (type == typeof (WorkspaceData)) {
         return Export ((WorkspaceData)data, ctx);
     } else if (type == typeof (WorkspaceUserData)) {
         return Export ((WorkspaceUserData)data, ctx);
     }
     throw new InvalidOperationException (String.Format ("Unknown type of {0}", type));
 }

        public TimeEntryJson Export (IDataStoreContext ctx, TimeEntryData data)
        {
            var userId = GetRemoteId<UserData> (ctx, data.UserId);
            var workspaceId = GetRemoteId<WorkspaceData> (ctx, data.WorkspaceId);
            var projectId = GetRemoteId<ProjectData> (ctx, data.ProjectId);
            var taskId = GetRemoteId<TaskData> (ctx, data.TaskId);
            var tags = GetTimeEntryTags (ctx, data.Id);

            return new TimeEntryJson () {
                Id = data.RemoteId,
                ModifiedAt = data.ModifiedAt.ToUtc (),
                Description = data.Description,
                IsBillable = data.IsBillable,
                StartTime = data.StartTime.ToUtc (),
                StopTime = data.StopTime.ToUtc (),
                DurationOnly = data.DurationOnly,
                Duration = EncodeDuration (data),
                Tags = tags,
                UserId = userId,
                WorkspaceId = workspaceId,
                ProjectId = projectId,
                TaskId = taskId,
            };
        }

        private static void ImportJson (IDataStoreContext ctx, TimeEntryData data, TimeEntryJson json)
        {
            var userId = GetUserLocalId (ctx, json.UserId);
            var workspaceId = GetLocalId<WorkspaceData> (ctx, json.WorkspaceId);
            var projectId = GetLocalId<ProjectData> (ctx, json.ProjectId);
            var taskId = GetLocalId<TaskData> (ctx, json.TaskId);

            data.Description = json.Description;
            data.IsBillable = json.IsBillable;
            data.DurationOnly = json.DurationOnly;
            data.UserId = userId;
            data.WorkspaceId = workspaceId;
            data.ProjectId = projectId;
            data.TaskId = taskId;
            DecodeDuration (data, json);

            ImportCommonJson (data, json);
        }

 private static void ImportJson (IDataStoreContext ctx, ClientData data, ClientJson json)
 {
     data.Name = json.Name;
     data.WorkspaceId = GetLocalId<WorkspaceData> (ctx, json.WorkspaceId);
     ImportCommonJson (data, json);
 }