Method Detail

• getMerchant

  @GET(value = APIConst.URL_MERCHANT + "/{id}") abstract Call<MenigaMerchant> getMerchant(long id)

• getMerchants

  @GET(value = APIConst.URL_MERCHANT) abstract Call<List<MenigaMerchant>> getMerchants(Map<String, String> queryMap)

• getTopMerchants

  @POST(value = APIConst.URL_TOP_MERCHANT) abstract Call<List<MenigaTopMerchant>> getTopMerchants(GetTopMerchants req)

• deleteTransactions

  @DELETE(value = APIConst.URL_TRANSACTIONS) abstract Call<Void> deleteTransactions(Map<String, String> queryMap)

• getTransactions

  @GET(value = APIConst.URL_TRANSACTIONS) abstract Call<MenigaTransactionPage> getTransactions(Map<String, String> queryMap)

• createTransaction

  @POST(value = APIConst.URL_TRANSACTIONS) abstract Call<MenigaTransaction> createTransaction(CreateTransaction body)

• updateTransactions

  @PUT(value = APIConst.URL_TRANSACTIONS) abstract Call<MenigaTransactionUpdate> updateTransactions(Map<String, String> transactionIds, UpdateTransactions req)

• getTransaction

  @GET(value = APIConst.URL_TRANSACTIONS + "/{id}?include=Account,Merchant") abstract Call<MenigaTransaction> getTransaction(long transId)

• updateTransaction

  @PUT(value = APIConst.URL_TRANSACTIONS + "/{id}") abstract Call<MenigaTransactionUpdate> updateTransaction(long transactionId, UpdateTransaction req)

• deleteTransaction

  @DELETE(value = APIConst.URL_TRANSACTIONS + "/{id}") abstract Call<Void> deleteTransaction(long transactionId)

• getTransactionSeries

  @POST(value = APIConst.URL_TRANSACTIONS_SERIES) abstract Call<List<MenigaTransactionSeries>> getTransactionSeries(GetTransactionSeries req)

• createComment

  @POST(value = APIConst.URL_TRANSACTIONS + "/{id}/" + APIConst.COMMENTS) abstract Call<MenigaComment> createComment(long transactionId, CreateComment comment)

• updateComment

  @PUT(value = APIConst.URL_TRANSACTIONS + "/{id}/" + APIConst.COMMENTS + "/{commentId}") abstract Call<Void> updateComment(long transactionId, long commentId, UpdateComment comment)

• deleteComment

  @DELETE(value = APIConst.URL_TRANSACTIONS + "/{id}/" + APIConst.COMMENTS + "/{commentId}") abstract Call<Void> deleteComment(long transactionId, long commentId)

• addComments

  @POST(value = APIConst.URL_TRANSACTIONS + "/" + APIConst.COMMENTS) abstract Call<List<MenigaComment>> addComments(AddComments req)

• fetchSplitTransactions

  @GET(value = APIConst.URL_TRANSACTIONS + "/{id}/" + APIConst.SPLIT) abstract Call<List<MenigaTransaction>> fetchSplitTransactions(long parentId)

• splitTransaction

  @POST(value = APIConst.URL_TRANSACTIONS + "/{id}/" + APIConst.SPLIT) abstract Call<List<MenigaTransaction>> splitTransaction(long transactionId, SplitTransaction req)

• updateSplits

  @PUT(value = APIConst.URL_TRANSACTIONS + "/{id}/" + APIConst.SPLIT) abstract Call<List<MenigaTransaction>> updateSplits(long transactionId, List<UpdateSplits> req)

• recategorizeTransactions

  @POST(value = APIConst.URL_TRANSACTIONS + "/recategorize") abstract Call<Void> recategorizeTransactions(RecategorizeTransactions req)

• getTransactionRules

  @GET(value = APIConst.URL_TRANSACTIONS + "/" + APIConst.RULES) abstract Call<List<MenigaTransactionRule>> getTransactionRules()

• createTransactionRule

  @POST(value = APIConst.URL_TRANSACTIONS + "/" + APIConst.RULES) abstract Call<MenigaTransactionRule> createTransactionRule(Map<String, String> queryMap, CreateTransactionRule req)

• deleteTransactionRule

  @DELETE(value = APIConst.URL_TRANSACTIONS + "/" + APIConst.RULES + "/{id}") abstract Call<Void> deleteTransactionRule(long id)

• getTransactionRule

  @GET(value = APIConst.URL_TRANSACTIONS + "/" + APIConst.RULES + "/{id}") abstract Call<MenigaTransactionRule> getTransactionRule(long id)

• updateTransactionRule

  @PUT(value = APIConst.URL_TRANSACTIONS + "/" + APIConst.RULES + "/{id}") abstract Call<Void> updateTransactionRule(long id, Map<String, String> queryMap, UpdateTransactionRule req)

• getTags

  @GET(value = APIConst.URL_TAGS) abstract Call<List<MenigaTag>> getTags()

• getTag

  @GET(value = APIConst.URL_TAGS + "/{id}") abstract Call<MenigaTag> getTag(long tagId)

• startSync

  @POST(value = APIConst.URL_SYNC) abstract Call<MenigaSync> startSync(StartSync req)

• startRealmSync

  @POST(value = APIConst.URL_SYNC_REALM + "/{id}") abstract Call<MenigaSync> startRealmSync(StartRealmSync req, long realmUserId)

• getSyncStatus

  @GET(value = APIConst.URL_SYNC) abstract Call<MenigaSyncStatus> getSyncStatus()

• getSync

  @GET(value = APIConst.URL_SYNC + "/{id}") abstract Call<MenigaSync> getSync(long id)

• getRealmAuthMethod

  @POST(value = APIConst.URL_SYNC + APIConst.REALM + "/{id}" + APIConst.AUTH) abstract Call<MenigaRealmAuthResponse> getRealmAuthMethod(long id, GetRealmAuthMethod req)

• getRealmAccounts

  @GET(value = APIConst.URL_SYNC + APIConst.ACCOUNTS + "/{id}") abstract Call<List<MenigaRealmAccount>> getRealmAccounts(long id, Map<String, String> query)

• addRealmAccountsToMeniga

  @POST(value = APIConst.URL_SYNC + APIConst.ACCOUNTS + "/{id}" + APIConst.AUTHORIZE) abstract Call<List<MenigaRealmAccount>> addRealmAccountsToMeniga(long realmUserId, List<MenigaRealmAccount> realmAccounts, Map<String, String> query)

• getUserEvents

  @GET(value = APIConst.URL_USER_EVENT_SUBSCRIPTIONS + APIConst.UE_DETAILS) abstract Call<List<MenigaUserEvent>> getUserEvents()

• setSubscription

  @PUT(value = APIConst.URL_USER_EVENT_SUBSCRIPTIONS) abstract Call<Void> setSubscription(SetSubscription req)

• updateSettings

  @PUT(value = APIConst.URL_USER_EVENT_SUBSCRIPTIONS + APIConst.UE_DETAILS) abstract Call<Void> updateSettings(SetSubscriptionSettings req)

• getFeed

  @GET(value = APIConst.URL_FEED + "?include=Account,Merchant") abstract Call<MenigaFeed> getFeed(Map<String, String> query)

• getScheduledEvent

  @GET(value = APIConst.URL_FEED + "/{type}/{id}") abstract Call<MenigaScheduledEvent> getScheduledEvent(String type, long id)

• getEvent

  @GET(value = APIConst.URL_USER_EVENTS + "/{id}") abstract Call<MenigaFeedItem> getEvent(long id)

• getCategories

  @GET(value = APIConst.URL_CATEGORIES) abstract Call<List<MenigaCategory>> getCategories(Map<String, String> queryMap)

• getCategoryById

  @GET(value = APIConst.URL_CATEGORIES + "/{id}") abstract Call<MenigaCategory> getCategoryById(long categoryId, Map<String, String> queryMap)

• createUserCategory

  @POST(value = APIConst.URL_CATEGORIES) abstract Call<MenigaUserCategory> createUserCategory(CreateUserCategory req)

• deleteCategory

  @DELETE(value = APIConst.URL_CATEGORIES + "/{id}") abstract Call<Void> deleteCategory(long id, Map<String, String> stringStringMap)

• updateUserCategory

  @PUT(value = APIConst.URL_CATEGORIES + "/{id}") abstract Call<Void> updateUserCategory(long id, UpdateUserCategory req)

• getNetWorth

  @GET(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS + "/{id}") abstract Call<MenigaNetWorth> getNetWorth(long id)

• getNetWorths

  @GET(value = APIConst.URL_NETWORTH) abstract Call<List<MenigaNetWorth>> getNetWorths(Map<String, String> queryMap)

• updateBalance

  @PUT(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS + "/{id}" + APIConst.NW_BALANCEHISTORY + "/{historyid}") abstract Call<Void> updateBalance(long id, long historyid, UpdateHistoryBalance req)

• deleteBalance

  @DELETE(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS + "/{id}" + APIConst.NW_BALANCEHISTORY + "/{historyid}") abstract Call<Void> deleteBalance(long accountId, long balanceId)

• getNetWorthFirstBalanceEntry

  @GET(value = APIConst.URL_NETWORTH + APIConst.NW_FIRST_BALANCE) abstract Call<MenigaNetWorthBalance> getNetWorthFirstBalanceEntry(Map<String, String> queryMap)

• createNetWorthAccount

  @POST(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS) abstract Call<MenigaNetWorth> createNetWorthAccount(CreateNetWorthAccount body)

• deleteNetWorthAccount

  @DELETE(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS + "/{id}") abstract Call<Void> deleteNetWorthAccount(long id)

• updateNetWorthAccount

  @PUT(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS + "/{id}") abstract Call<Void> updateNetWorthAccount(long id, UpdatedNetWorthAccount req)

• createNetWorthBalanceHistory

  @POST(value = APIConst.URL_NETWORTH + APIConst.NW_ACCOUNTS + "/{id}" + APIConst.NW_BALANCEHISTORY) abstract Call<MenigaNetWorthBalance> createNetWorthBalanceHistory(long id, CreateNetWorthBalanceHistory req)

• getNetWorthTypes

  @GET(value = APIConst.URL_NETWORTH + APIConst.NW_TYPES) abstract Call<List<KeyVal<Long, String>>> getNetWorthTypes()

• getPublicSettings

  @GET(value = APIConst.URL_PUBLIC + APIConst.SETTINGS) abstract Call<MenigaPublicSettings> getPublicSettings()

• getTerms

  @GET(value = APIConst.URL_TERMS) abstract Call<List<MenigaTerms>> getTerms(String culture)

• getTerm

  @GET(value = APIConst.URL_TERMS + "/{typeId}") abstract Call<MenigaTerms> getTerm(String culture, long typeId)

• getTermTypes

  @GET(value = APIConst.URL_TERMS + APIConst.TYPES) abstract Call<List<MenigaTermType>> getTermTypes(String culture)

• acceptTerms

  @POST(value = APIConst.URL_TERMS + "/{typeId}" + APIConst.ACCEPT) abstract Call<Void> acceptTerms(long typeId)

• declineTerms

  @POST(value = APIConst.URL_TERMS + "/{typeId}" + APIConst.DECLINE) abstract Call<Void> declineTerms(long typeId)

• getUpcoming

  @GET(value = APIConst.URL_UPCOMING) abstract Call<List<MenigaUpcoming>> getUpcoming(Map<String, String> queryMap)

• getUpcoming

  @GET(value = APIConst.URL_UPCOMING + "/{id}") abstract Call<MenigaUpcoming> getUpcoming(long id)

• createUpcoming

  @POST(value = APIConst.URL_UPCOMING) abstract Call<List<MenigaUpcoming>> createUpcoming(CreateUpcoming req)

• updateUpcoming

  @PUT(value = APIConst.URL_UPCOMING + "/{id}") abstract Call<Void> updateUpcoming(long id, UpdateUpcoming req, Map<String, String> queryMap)

• deleteUpcoming

  @DELETE(value = APIConst.URL_UPCOMING + "/{id}") abstract Call<Void> deleteUpcoming(long id)

• deleteUpcomingSeries

  @DELETE(value = APIConst.URL_UPCOMING + APIConst.UPCOMING_RECURRINC + "/{id}") abstract Call<Void> deleteUpcomingSeries(long id)

• reconcileUpcoming

  @POST(value = APIConst.URL_UPCOMING + "/{id}/reconcile/{entityType}/{entityId}") abstract Call<Void> reconcileUpcoming(long id, String entityType, long entityId)

• getOrganizations

  @GET(value = APIConst.URL_ORGANIZATIONS) abstract Call<List<MenigaOrganization>> getOrganizations()

• genericGet

  @GET() abstract Call<Object> genericGet(String path, Map<String, String> headers, Map<String, String> query)

• genericHead

  @HEAD() abstract Call<Object> genericHead(String path, Map<String, String> headers, Map<String, String> query)

• genericOptions

  @OPTIONS() abstract Call<Object> genericOptions(String path, Map<String, String> headers, Map<String, String> query)

• genericPost

  @POST() abstract Call<Object> genericPost(String path, Map<String, String> headers, Object body, Map<String, String> query)

• genericPut

  @PUT() abstract Call<Object> genericPut(String path, Map<String, String> headers, Object body, Map<String, String> query)

• genericDelete

  @DELETE() abstract Call<Object> genericDelete(String path, Map<String, String> headers, Map<String, String> query)