diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 09ccecd..ebf81a8 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -5,12 +5,12 @@ plugins { android { namespace = "core.notevault" - compileSdk = 34 + compileSdk = 35 defaultConfig { applicationId = "core.notevault" minSdk = 28 - targetSdk = 34 + targetSdk = 35 versionCode = 1 versionName = "1.0" @@ -65,4 +65,5 @@ dependencies { // Optional: Unterstützung für Kotlin Coroutines oder RxJava implementation("androidx.room:room-ktx:$room_version") // Für Kotlin-Extensions implementation("androidx.room:room-rxjava3:$room_version") // Für RxJava-Unterstützung + implementation("androidx.work:work-runtime:2.10.0") } \ No newline at end of file diff --git a/app/src/main/java/core/notevault/MainActivity.java b/app/src/main/java/core/notevault/MainActivity.java index 9a50d38..2d90c9f 100644 --- a/app/src/main/java/core/notevault/MainActivity.java +++ b/app/src/main/java/core/notevault/MainActivity.java @@ -12,6 +12,8 @@ import android.widget.Toast; import androidx.fragment.app.Fragment; import androidx.fragment.app.FragmentManager; import androidx.navigation.fragment.NavHostFragment; +import androidx.work.OneTimeWorkRequest; +import androidx.work.WorkManager; import com.google.android.material.snackbar.Snackbar; import com.google.android.material.navigation.NavigationView; import androidx.navigation.NavController; @@ -22,6 +24,7 @@ import androidx.drawerlayout.widget.DrawerLayout; import androidx.appcompat.app.AppCompatActivity; import core.notevault.data.*; import core.notevault.databinding.ActivityMainBinding; +import core.notevault.sync.SyncWorker; import core.notevault.sync.auth.AuthRepository; import core.notevault.sync.auth.LoginCallback; import core.notevault.ui.gallery.GalleryFragment; @@ -35,8 +38,10 @@ import core.notevault.util.NoteSheetsUtil; import java.io.*; import java.nio.file.Files; import java.util.ArrayList; +import java.util.Calendar; import java.util.Date; import java.util.List; +import java.util.concurrent.TimeUnit; public class MainActivity extends AppCompatActivity implements MetaDataDialog.OnMetadataListener, ConcertEditorDialog.OnConcertEditorListener, ConcertSongSelector.OnSongSelectedListener, LoginCallback { @@ -68,6 +73,25 @@ public class MainActivity extends AppCompatActivity implements MetaDataDialog.On setupLoginButton(); musicDB = MusicDatabase.getDatabase(this); + scheduleSync(); + } + + public void scheduleSync() { + // Setze eine Uhrzeit für die Synchronisation + Calendar calendar = Calendar.getInstance(); + calendar.set(Calendar.HOUR_OF_DAY,11); + calendar.set(Calendar.MINUTE, 32); + calendar.set(Calendar.SECOND, 0); + + long triggerTime = calendar.getTimeInMillis(); // Zeitstempel für den Trigger + + // Erstelle die OneTimeWorkRequest für den SyncWorker + OneTimeWorkRequest syncRequest = new OneTimeWorkRequest.Builder(SyncWorker.class) + .setInitialDelay(triggerTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS) // Verzögerung bis zur Ausführung + .build(); + + // Planen des Workers mit WorkManager + WorkManager.getInstance(getBaseContext()).enqueue(syncRequest); } @Override diff --git a/app/src/main/java/core/notevault/data/Concert.java b/app/src/main/java/core/notevault/data/Concert.java index bf025ae..84087ff 100644 --- a/app/src/main/java/core/notevault/data/Concert.java +++ b/app/src/main/java/core/notevault/data/Concert.java @@ -1,26 +1,33 @@ package core.notevault.data; -import androidx.room.Entity; -import androidx.room.Ignore; -import androidx.room.PrimaryKey; +import androidx.room.*; +import core.notevault.data.sync.SyncStatus; +import core.notevault.data.sync.SyncStatusConverter; import java.text.SimpleDateFormat; +import java.time.LocalDateTime; import java.util.Date; import java.util.Locale; @Entity(tableName = "concerts") +@TypeConverters(SyncStatusConverter.class) public class Concert { @PrimaryKey(autoGenerate = true) private int id; + private String serverSpecificConcertID; private String title; private String concertDate; + private SyncStatus syncStatus; + + private LocalDateTime lastModified; @Ignore public Concert(String title, String concertDate) { this.title = title; this.concertDate = concertDate; + this.lastModified = LocalDateTime.now(); } public Concert() { @@ -56,4 +63,28 @@ public class Concert { public void setConcertDate(String concertDate) { this.concertDate = concertDate; } + + public String getServerSpecificConcertID() { + return serverSpecificConcertID; + } + + public void setServerSpecificConcertID(String serverSpecificConcertID) { + this.serverSpecificConcertID = serverSpecificConcertID; + } + + public SyncStatus getSyncStatus() { + return syncStatus; + } + + public void setSyncStatus(SyncStatus syncStatus) { + this.syncStatus = syncStatus; + } + + public LocalDateTime getLastModified() { + return lastModified; + } + + public void setLastModified(LocalDateTime lastModified) { + this.lastModified = lastModified; + } } diff --git a/app/src/main/java/core/notevault/data/DateConverter.java b/app/src/main/java/core/notevault/data/DateConverter.java new file mode 100644 index 0000000..5125be5 --- /dev/null +++ b/app/src/main/java/core/notevault/data/DateConverter.java @@ -0,0 +1,20 @@ +package core.notevault.data; + +import androidx.room.TypeConverter; + +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; + +public class DateConverter { + // Konvertiere LocalDateTime in String + @TypeConverter + public static String fromLocalDateTime(LocalDateTime localDateTime) { + return localDateTime == null ? null : localDateTime.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME); + } + + // Konvertiere String zurück in LocalDateTime + @TypeConverter + public static LocalDateTime toLocalDateTime(String dateTimeString) { + return dateTimeString == null ? null : LocalDateTime.parse(dateTimeString, DateTimeFormatter.ISO_LOCAL_DATE_TIME); + } +} diff --git a/app/src/main/java/core/notevault/data/MusicDatabase.java b/app/src/main/java/core/notevault/data/MusicDatabase.java index 8ec1a8d..3266150 100644 --- a/app/src/main/java/core/notevault/data/MusicDatabase.java +++ b/app/src/main/java/core/notevault/data/MusicDatabase.java @@ -1,11 +1,12 @@ package core.notevault.data; import android.content.Context; -import androidx.room.Room; -import androidx.room.RoomDatabase; -import androidx.room.Database; +import androidx.room.*; +import core.notevault.data.sync.SyncResponse; +import core.notevault.data.sync.SyncStatusConverter; -@Database(entities = {MusicNote.class, NoteSheet.class, Concert.class, ConcertSong.class}, version = 2, exportSchema = false) +@Database(entities = {MusicNote.class, NoteSheet.class, Concert.class, ConcertSong.class, SyncResponse.class}, version = 2, exportSchema = false) +@TypeConverters(DateConverter.class) public abstract class MusicDatabase extends RoomDatabase { public abstract MusicNoteDAO musicNoteDao(); diff --git a/app/src/main/java/core/notevault/data/MusicNoteDAO.java b/app/src/main/java/core/notevault/data/MusicNoteDAO.java index dbd2790..c6e1677 100644 --- a/app/src/main/java/core/notevault/data/MusicNoteDAO.java +++ b/app/src/main/java/core/notevault/data/MusicNoteDAO.java @@ -1,7 +1,10 @@ package core.notevault.data; import androidx.room.*; +import core.notevault.data.sync.SyncResponse; +import core.notevault.data.sync.SyncStatus; +import java.time.LocalDateTime; import java.util.List; @Dao @@ -19,6 +22,9 @@ public interface MusicNoteDAO { @Query("SELECT * FROM note_sheets WHERE musicNoteId = :musicNoteId") List getNoteSheetsForMusicSong(long musicNoteId); + @Query("SELECT * FROM concerts WHERE syncStatus = :status") + List getConcertsWithSyncStatus(SyncStatus status); + @Insert void insertConcert(Concert concert); @@ -43,5 +49,18 @@ public interface MusicNoteDAO { @Query("DELETE FROM concert_songs WHERE concertID = :concertID AND musicNoteID = :songID") void deleteConcertSong(long songID, int concertID); + @Query("UPDATE concerts SET serverSpecificConcertID = :serverUUID WHERE id = :concertID") + @Transaction + void updateConcertServerUUID(String serverUUID, int concertID); + // Methode für das batchweise Update der Konzert-ServerUUIDs + @Query("DELETE FROM concerts WHERE serverSpecificConcertID IN (:serverSpecificIDs)") + void deleteConcerts(List serverSpecificIDs); + + @Insert + @Transaction + void insertSyncResponses(List syncResponses); + + @Query("SELECT MAX(lastModified) FROM concerts") + LocalDateTime getLatestSyncTimestamp(); } diff --git a/app/src/main/java/core/notevault/data/sync/SyncAction.java b/app/src/main/java/core/notevault/data/sync/SyncAction.java new file mode 100644 index 0000000..0e721f0 --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncAction.java @@ -0,0 +1,6 @@ +package core.notevault.data.sync; + +public enum SyncAction { + TOBEUPLOADED, + TOBEDOWNLOADED +} diff --git a/app/src/main/java/core/notevault/data/sync/SyncActionConverter.java b/app/src/main/java/core/notevault/data/sync/SyncActionConverter.java new file mode 100644 index 0000000..51c4caa --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncActionConverter.java @@ -0,0 +1,15 @@ +package core.notevault.data.sync; + +import androidx.room.TypeConverter; + +public class SyncActionConverter { + @TypeConverter + public static SyncAction fromInt(int value) { + return SyncAction.values()[value]; + } + + @TypeConverter + public static int toInt(SyncAction action) { + return action.ordinal(); + } +} diff --git a/app/src/main/java/core/notevault/data/sync/SyncObject.java b/app/src/main/java/core/notevault/data/sync/SyncObject.java new file mode 100644 index 0000000..3a7ad53 --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncObject.java @@ -0,0 +1,5 @@ +package core.notevault.data.sync; + +public enum SyncObject { + CONCERT +} diff --git a/app/src/main/java/core/notevault/data/sync/SyncObjectConverter.java b/app/src/main/java/core/notevault/data/sync/SyncObjectConverter.java new file mode 100644 index 0000000..e2e67b5 --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncObjectConverter.java @@ -0,0 +1,15 @@ +package core.notevault.data.sync; + +import androidx.room.TypeConverter; + +public class SyncObjectConverter { + @TypeConverter + public static SyncObject fromInt(int value) { + return SyncObject.values()[value]; + } + + @TypeConverter + public static int toInt(SyncObject object) { + return object.ordinal(); + } +} diff --git a/app/src/main/java/core/notevault/data/sync/SyncResponse.java b/app/src/main/java/core/notevault/data/sync/SyncResponse.java new file mode 100644 index 0000000..1acefc5 --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncResponse.java @@ -0,0 +1,59 @@ +package core.notevault.data.sync; + + +import androidx.room.Entity; +import androidx.room.Ignore; +import androidx.room.PrimaryKey; +import androidx.room.TypeConverters; + +@Entity(tableName = "sync_actions") +@TypeConverters({SyncStatusConverter.class, SyncObjectConverter.class}) +public class SyncResponse { + @PrimaryKey(autoGenerate = true) + private long id; + private String serverUUID; + private SyncAction syncAction; + private SyncObject syncObject; + + @Ignore + public SyncResponse(String serverUUID, SyncAction syncAction, SyncObject syncObject) { + this.serverUUID = serverUUID; + this.syncAction = syncAction; + this.syncObject = syncObject; + } + + public SyncResponse() { + } + + public String getServerUUID() { + return serverUUID; + } + + public void setServerUUID(String serverUUID) { + this.serverUUID = serverUUID; + } + + public SyncAction getSyncAction() { + return syncAction; + } + + public void setSyncAction(SyncAction syncAction) { + this.syncAction = syncAction; + } + + public SyncObject getSyncObject() { + return syncObject; + } + + public void setSyncObject(SyncObject syncObject) { + this.syncObject = syncObject; + } + + public long getId() { + return id; + } + + public void setId(long id) { + this.id = id; + } +} diff --git a/app/src/main/java/core/notevault/data/sync/SyncStatus.java b/app/src/main/java/core/notevault/data/sync/SyncStatus.java new file mode 100644 index 0000000..09e686e --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncStatus.java @@ -0,0 +1,9 @@ +package core.notevault.data.sync; + +public enum SyncStatus { + CREATED, + DELETED, + MODIFIED, + REMOTE_MODIFIED, + SYNCED; +} diff --git a/app/src/main/java/core/notevault/data/sync/SyncStatusConverter.java b/app/src/main/java/core/notevault/data/sync/SyncStatusConverter.java new file mode 100644 index 0000000..a8ac3eb --- /dev/null +++ b/app/src/main/java/core/notevault/data/sync/SyncStatusConverter.java @@ -0,0 +1,15 @@ +package core.notevault.data.sync; + +import androidx.room.TypeConverter; + +public class SyncStatusConverter { + @TypeConverter + public static SyncStatus fromInt(int value) { + return SyncStatus.values()[value]; + } + + @TypeConverter + public static int toInt(SyncStatus syncStatus) { + return syncStatus.ordinal(); + } +} diff --git a/app/src/main/java/core/notevault/sync/ApiClient.java b/app/src/main/java/core/notevault/sync/ApiClient.java index 17aa6b5..1ba676f 100644 --- a/app/src/main/java/core/notevault/sync/ApiClient.java +++ b/app/src/main/java/core/notevault/sync/ApiClient.java @@ -4,6 +4,7 @@ import android.content.Context; import android.content.SharedPreferences; import core.notevault.sync.auth.AuthInterceptor; import okhttp3.OkHttpClient; +import okhttp3.logging.HttpLoggingInterceptor; import retrofit2.Retrofit; import retrofit2.converter.gson.GsonConverterFactory; @@ -12,9 +13,13 @@ public class ApiClient { public static Retrofit getRetrofitInstance(Context context) { if (retrofit == null) { + HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(); + loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY); + SharedPreferences sharedPreferences = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE); OkHttpClient client = new OkHttpClient.Builder() .addInterceptor(new AuthInterceptor(sharedPreferences)) + .addInterceptor(loggingInterceptor) .build(); retrofit = new Retrofit.Builder() diff --git a/app/src/main/java/core/notevault/sync/SyncWorker.java b/app/src/main/java/core/notevault/sync/SyncWorker.java new file mode 100644 index 0000000..7caf926 --- /dev/null +++ b/app/src/main/java/core/notevault/sync/SyncWorker.java @@ -0,0 +1,127 @@ +package core.notevault.sync; +import android.content.Context; +import android.util.Log; +import androidx.annotation.NonNull; +import androidx.work.Worker; +import androidx.work.WorkerParameters; +import core.notevault.data.Concert; +import core.notevault.data.MusicDatabase; +import core.notevault.data.MusicNoteDAO; +import core.notevault.data.sync.SyncAction; +import core.notevault.data.sync.SyncObject; +import core.notevault.data.sync.SyncResponse; +import core.notevault.data.sync.SyncStatus; +import core.notevault.sync.synchronisation.*; +import retrofit2.Call; +import retrofit2.Callback; +import retrofit2.Response; + +import java.io.IOException; +import java.time.LocalDateTime; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.stream.Collectors; + +public class SyncWorker extends Worker{ + private SyncService syncService; + private MusicNoteDAO database; + public SyncWorker(@NonNull Context context, @NonNull WorkerParameters workerParams) { + super(context, workerParams); + this.syncService = ApiClient.getRetrofitInstance(context).create(SyncService.class); + MusicDatabase musicDatabase = MusicDatabase.getDatabase(context); + database = musicDatabase.musicNoteDao(); + } + + @NonNull + @Override + public Result doWork() { + SyncRequest concertSync = buildConcertSyncRequest(); + + final CountDownLatch latch = new CountDownLatch(1); + final Result[] result = {Result.failure()}; + + syncWithServer(concertSync, new Callback() { + @Override + public void onResponse(Call call, Response response) { + if(response.isSuccessful()) { + result[0] = Result.success(); + Log.d("SyncWorker", "Sync finished, process now"); + processConcertSynResponse(response.body()); + } else { + Log.d("SyncWorker", "Sync failed"); + if (response.errorBody() != null) { + try { + String errorBody = response.errorBody().string(); + Log.d("SyncWorker", "Error Body: " + errorBody); + } catch (IOException e) { + e.printStackTrace(); + } + } + result[0] = Result.failure(); + } + latch.countDown(); + } + + @Override + public void onFailure(Call call, Throwable throwable) { + result[0] = Result.failure(); + Log.d("SyncWorker", "Sync failure"); + latch.countDown(); + } + }); + + try { + latch.await(); + } catch (InterruptedException e) { +// throw new RuntimeException(e); + } + return result[0]; + } + + private SyncRequest buildConcertSyncRequest() { + List createdConcerts = database.getConcertsWithSyncStatus(SyncStatus.CREATED); + List deletedConcerts = database.getConcertsWithSyncStatus(SyncStatus.DELETED); + List modifiedConcerts = database.getConcertsWithSyncStatus(SyncStatus.MODIFIED); + + + List deviceIDsCreatedConcerts = createdConcerts.stream().map(Concert::getId).collect(Collectors.toList()); + List modifiedSyncRequests = modifiedConcerts.stream().map(concert -> + new SyncChangeRequest(concert.getServerSpecificConcertID(), concert.getLastModified())).collect(Collectors.toList()); + List deletedSyncRequests = deletedConcerts.stream().map(concert -> + new SyncChangeRequest(concert.getServerSpecificConcertID(), concert.getLastModified())).collect(Collectors.toList()); + + Log.d("SyncWorker", "Build SyncRequest"); + // Datenbankabfrage: Nur IDs mit Zustand "Modified" oder "Deleted" abrufen + // Dies ist abhängig von der spezifischen Implementierung der Datenbank + return new SyncRequest(database.getLatestSyncTimestamp(), deletedSyncRequests, modifiedSyncRequests, deviceIDsCreatedConcerts); + } + + private void syncWithServer(SyncRequest syncRequest, Callback callback) { + syncService.syncConcerts(syncRequest).enqueue(callback); + } + + private void processConcertSynResponse(SyncResponseModel syncResponse) { + Log.d("SyncWorker", "Process SyncResponse"); + //Assign local Concert entries the provided Server ID + List syncResponses = new ArrayList<>(); + for(SyncCreateResponse createResponse : syncResponse.getCreateResonses()) { + database.updateConcertServerUUID(createResponse.getServerObjectUUID(), createResponse.getDeviceSpecificObjectID()); + syncResponses.add(new SyncResponse(createResponse.getServerObjectUUID(), SyncAction.TOBEUPLOADED, SyncObject.CONCERT)); + } + + //Delete Concerts that the server has marked as deleted + database.deleteConcerts(syncResponse.getToBeDeleted()); + + //Persist SyncResponse + + for(String toBeDownloaded : syncResponse.getToBeDownloaded()) { + syncResponses.add(new SyncResponse(toBeDownloaded, SyncAction.TOBEDOWNLOADED, SyncObject.CONCERT)); + } + + for(String toBeUploaded : syncResponse.getToBeUploaded()) { + syncResponses.add(new SyncResponse(toBeUploaded, SyncAction.TOBEUPLOADED, SyncObject.CONCERT)); + } + database.insertSyncResponses(syncResponses); + } +} diff --git a/app/src/main/java/core/notevault/sync/auth/AuthInterceptor.java b/app/src/main/java/core/notevault/sync/auth/AuthInterceptor.java index 2836fa4..3f7d7ee 100644 --- a/app/src/main/java/core/notevault/sync/auth/AuthInterceptor.java +++ b/app/src/main/java/core/notevault/sync/auth/AuthInterceptor.java @@ -1,6 +1,7 @@ package core.notevault.sync.auth; import android.content.SharedPreferences; +import android.util.Log; import okhttp3.Interceptor; import okhttp3.Request; import okhttp3.Response; @@ -13,12 +14,17 @@ public class AuthInterceptor implements Interceptor { public AuthInterceptor(SharedPreferences sharedPreferences) { this.sharedPreferences = sharedPreferences; + String token = sharedPreferences.getString("jwt_token", null); } @Override public Response intercept(Chain chain) throws IOException { Request originalRequest = chain.request(); + if(originalRequest.url().encodedPath().equals("/api/v1/auth/login")) { + return chain.proceed(originalRequest); + } + String token = sharedPreferences.getString("jwt_token", null); if (token == null) { return chain.proceed(originalRequest); diff --git a/app/src/main/java/core/notevault/sync/synchronisation/SyncChangeRequest.java b/app/src/main/java/core/notevault/sync/synchronisation/SyncChangeRequest.java new file mode 100644 index 0000000..213b2ff --- /dev/null +++ b/app/src/main/java/core/notevault/sync/synchronisation/SyncChangeRequest.java @@ -0,0 +1,29 @@ +package core.notevault.sync.synchronisation; + +import java.time.LocalDateTime; + +public class SyncChangeRequest { + private String serverUUID; + private LocalDateTime lastModified; + + public SyncChangeRequest(String serverUUID, LocalDateTime lastModified) { + this.serverUUID = serverUUID; + this.lastModified = lastModified; + } + + public String getServerUUID() { + return serverUUID; + } + + public void setServerUUID(String serverUUID) { + this.serverUUID = serverUUID; + } + + public LocalDateTime getLastModified() { + return lastModified; + } + + public void setLastModified(LocalDateTime lastModified) { + this.lastModified = lastModified; + } +} diff --git a/app/src/main/java/core/notevault/sync/synchronisation/SyncCreateResponse.java b/app/src/main/java/core/notevault/sync/synchronisation/SyncCreateResponse.java new file mode 100644 index 0000000..1514b6d --- /dev/null +++ b/app/src/main/java/core/notevault/sync/synchronisation/SyncCreateResponse.java @@ -0,0 +1,22 @@ +package core.notevault.sync.synchronisation; + +public class SyncCreateResponse { + private String serverObjectUUID; + private int deviceSpecificObjectID; + + public String getServerObjectUUID() { + return serverObjectUUID; + } + + public void setServerObjectUUID(String serverObjectUUID) { + this.serverObjectUUID = serverObjectUUID; + } + + public int getDeviceSpecificObjectID() { + return deviceSpecificObjectID; + } + + public void setDeviceSpecificObjectID(int deviceSpecificObjectID) { + this.deviceSpecificObjectID = deviceSpecificObjectID; + } +} diff --git a/app/src/main/java/core/notevault/sync/synchronisation/SyncRequest.java b/app/src/main/java/core/notevault/sync/synchronisation/SyncRequest.java new file mode 100644 index 0000000..a16dcdb --- /dev/null +++ b/app/src/main/java/core/notevault/sync/synchronisation/SyncRequest.java @@ -0,0 +1,50 @@ +package core.notevault.sync.synchronisation; + +import java.time.LocalDateTime; +import java.util.List; + +public class SyncRequest { + private LocalDateTime lastSync; + private List deletedConcerts; + private List modifiedConcerts; + private List createdConcerts; + + public SyncRequest(LocalDateTime lastSync, List deletedConcerts, List modifiedConcerts, List createdConcerts) { + this.lastSync = lastSync; + this.deletedConcerts = deletedConcerts; + this.modifiedConcerts = modifiedConcerts; + this.createdConcerts = createdConcerts; + } + + public LocalDateTime getLastSync() { + return lastSync; + } + + public void setLastSync(LocalDateTime lastSync) { + this.lastSync = lastSync; + } + + public List getDeletedConcerts() { + return deletedConcerts; + } + + public void setDeletedConcerts(List deletedConcerts) { + this.deletedConcerts = deletedConcerts; + } + + public List getModifiedConcerts() { + return modifiedConcerts; + } + + public void setModifiedConcerts(List modifiedConcerts) { + this.modifiedConcerts = modifiedConcerts; + } + + public List getCreatedConcerts() { + return createdConcerts; + } + + public void setCreatedConcerts(List createdConcerts) { + this.createdConcerts = createdConcerts; + } +} diff --git a/app/src/main/java/core/notevault/sync/synchronisation/SyncResponseModel.java b/app/src/main/java/core/notevault/sync/synchronisation/SyncResponseModel.java new file mode 100644 index 0000000..3cbf003 --- /dev/null +++ b/app/src/main/java/core/notevault/sync/synchronisation/SyncResponseModel.java @@ -0,0 +1,42 @@ +package core.notevault.sync.synchronisation; + +import java.util.List; + +public class SyncResponseModel { + private List toBeUploaded; + private List toBeDownloaded; + private List toBeDeleted; + private List createResonses; + + public List getToBeUploaded() { + return toBeUploaded; + } + + public void setToBeUploaded(List toBeUploaded) { + this.toBeUploaded = toBeUploaded; + } + + public List getToBeDownloaded() { + return toBeDownloaded; + } + + public void setToBeDownloaded(List toBeDownloaded) { + this.toBeDownloaded = toBeDownloaded; + } + + public List getToBeDeleted() { + return toBeDeleted; + } + + public void setToBeDeleted(List toBeDeleted) { + this.toBeDeleted = toBeDeleted; + } + + public List getCreateResonses() { + return createResonses; + } + + public void setCreateResonses(List createResonses) { + this.createResonses = createResonses; + } +} diff --git a/app/src/main/java/core/notevault/sync/synchronisation/SyncService.java b/app/src/main/java/core/notevault/sync/synchronisation/SyncService.java new file mode 100644 index 0000000..c9df3cd --- /dev/null +++ b/app/src/main/java/core/notevault/sync/synchronisation/SyncService.java @@ -0,0 +1,12 @@ +package core.notevault.sync.synchronisation; + +import core.notevault.data.sync.SyncResponse; +import retrofit2.Call; +import retrofit2.http.Body; +import retrofit2.http.POST; + +public interface SyncService { + + @POST("api/v1/sync/concerts") + Call syncConcerts(@Body SyncRequest syncRequest); +}