Yike App Common

https://github.com/xiaojinzi123/yike-app-common
Admin
Provides shared utilities, components, or resources for the Yike App project.
Tokens:5,100
Snippets:26
Trust Score:8.9
License:GPL-2.0
Update:9 months ago
Show doc for...
Tokens:
Raw
### Manage Books using TallyDataSourceSpi in Kotlin

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Provides Kotlin code examples for inserting, retrieving, subscribing to, and switching account books using the TallyDataSourceSpi. It also shows how to get the currently selected book, throwing an exception if none is selected.

```kotlin
// Insert books
val bookIds: List<String> = tallyDataSourceSpi.insertBookList(
    targetList = listOf(
        TallyBookInsertDto(
            userId = "user123",
            isSystem = false,
            type = TallyBookDto.TYPE_NORMAL,
            name = "Family Budget",
            iconName = "family1"
        )
    )
)

// Get all books
val allBooks: List<TallyBookDto> = tallyDataSourceSpi.getAllBookList()

// Subscribe to selected book
val selectedBookFlow: Flow<TallyBookDto?> = tallyDataSourceSpi.selectedBookStateOb

// Switch active book
tallyDataSourceSpi.switchBook(
    bookId = "book456",
    isTipAfterSwitch = true
)

// Get required selected book (throws NoBookSelectException if none selected)
val currentBook: TallyBookDto = tallyDataSourceSpi.requiredSelectedBookInfo()
```

--------------------------------

### Perform Authentication Operations with UserSpi in Kotlin

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Provides Kotlin code examples for user authentication operations using UserSpi, including logging in with a phone verification code, logging in via WeChat (handling exceptions), logging out, clearing user info, and refreshing token/VIP status.

```kotlin
// Login with phone verification code
userSpi.loginByCheckCode(
    phoneNumber = "13800138000",
    checkCode = "123456"
)

// Login with WeChat (throws WxNotInstallException or ThirdLoginBindPhoneException)
try {
    userSpi.loginByWx()
} catch (e: WxNotInstallException) {
    // WeChat not installed
} catch (e: ThirdLoginBindPhoneException) {
    // Need to bind phone number
    userSpi.loginByBindWx(
        authId = e.authId,
        phoneNumber = "13800138000",
        checkCode = "123456"
    )
}

// Logout (waits for sync, clears data, opens login screen)
userSpi.logoutForBusinessLogic()

// Clear user info
userSpi.clearUserInfo()

// Refresh token info
userSpi.updateTokenInfoAction().invoke()

// Refresh VIP info
userSpi.updateVipInfoAction().invoke()
```

--------------------------------

### TallyCategoryDto - Create and Use Category Data Models (Kotlin)

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Defines a hierarchical category system for income and spending. The code examples show how to use category types (income/spending), create new category DTOs with parent-child relationships, and convert category types from database strings.

```kotlin
// Category types
val incomeCategory = TallyCategoryDto.Companion.TallyCategoryType.INCOME     // moneyTransform = 1
val spendingCategory = TallyCategoryDto.Companion.TallyCategoryType.SPENDING // moneyTransform = -1

// Creating a category
val categoryInsert = TallyCategoryInsertDto(
    userId = "user123",
    bookId = "book456",
    parentId = null,  // Root category (null) or parent category ID
    type = TallyCategoryDto.TYPE_SPENDING,  // "spending" or "income"
    name = "Food & Dining",
    iconName = "chopsticksFork1",
    sort = System.currentTimeMillis()
)

// Converting from type string
val categoryType = TallyCategoryDto.Companion.TallyCategoryType.fromDbStr("spending")
```

--------------------------------

### Manage Reactive Bill List with Kotlin Flows

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

This snippet demonstrates how to manage a reactive bill list using Kotlin Flows. It covers creating use cases, setting query conditions, subscribing to paginated bill lists, loading more pages, and handling navigation or contextual actions like showing a popup menu.

```kotlin
// Create use case with query condition
val queryConditionUseCase = CommonBillQueryConditionUseCaseImpl()
val billListUseCase = CommonBillListUseCaseImpl(
    commonBillQueryConditionUseCase = queryConditionUseCase
)

// Set query condition
queryConditionUseCase.queryConditionStateOb.emit(
    TallyDataSourceSpi.Companion.BillQueryConditionDto(
        bookIdList = listOf("book456"),
        isDeleted = false
    )
)

// Subscribe to paginated bill list
billListUseCase.billListStateOb.collect { billList: List<TallyBillDetailDto> ->
    // Update UI with bill list
}

// Load more pages
billListUseCase.addIntent(CommonBillListIntent.LoadMore)

// Navigate to bill detail
billListUseCase.addIntent(
    CommonBillListIntent.ToBillDetail(
        context = context,
        billId = "bill123"
    )
)

// Show bill popup menu (copy, refund, edit, delete)
billListUseCase.addIntent(
    CommonBillListIntent.PopMenu(
        context = context,
        billId = "bill123"
    )
)
```

--------------------------------

### Manage Labels using TallyDataSourceSpi in Kotlin

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Demonstrates Kotlin code for managing labels within a book, including inserting new labels, subscribing to all labels in a book, retrieving labels for a specific bill, and finding bill IDs associated with specific labels.

```kotlin
// Insert label
val labelId: String = tallyDataSourceSpi.insertLabel(
    target = TallyLabelInsertDto(
        userId = "user123",
        bookId = "book456",
        name = "Important",
        sort = System.currentTimeMillis()
    ),
    isNeedSync = true
)

// Subscribe to all labels in a book
val labelsFlow: Flow<List<TallyLabelDto>> = tallyDataSourceSpi.subscribeAllLabel(
    bookId = "book456"
)

// Get labels for a specific bill
val billLabels: List<TallyLabelDto> = tallyDataSourceSpi.getLabelListByBillId(
    bookId = "book456",
    billId = "bill123"
)

// Get bill IDs with specific labels
val billIds: List<String> = tallyDataSourceSpi.getBillIdListByLabelIdList(
    labelIdList = listOf("label1", "label2"),
    isExcludeDeleted = true
)
```

--------------------------------

### TallyAccountDto - Create and Use Account Data Models (Kotlin)

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Represents financial accounts within a book, storing initial and current balances. It demonstrates creating new account DTOs and outlines the structure of the TallyAccountDto, including fields for balance, exclusion from statistics, and default account settings.

```kotlin
// Creating an account
val accountInsert = TallyAccountInsertDto(
    userId = "user123",
    bookId = "book456",
    iconName = "wallet1",
    name = "Cash Wallet",
    balanceInit = 100000L,  // Initial balance: 1000.00 yuan
    isExcluded = false,     // Include in net worth calculation
    isDefault = true,       // Default account for new bills
    timeCreate = System.currentTimeMillis()
)

// Account DTO structure
data class TallyAccountDto(
    val id: String,
    val userId: String,
    val bookId: String,
    val name: String?,
    val iconName: String?,
    val balanceInit: MoneyFen,      // Initial balance in fen
    val balanceCurrent: MoneyFen,   // Calculated current balance
    val isExcluded: Boolean,
    val isDefault: Boolean,
    val timeCreate: Long,
    val timeModify: Long?,
    val isDeleted: Boolean,
    val isSync: Boolean
)
```

--------------------------------

### Raw Query with Dynamic Conditions for Bills

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Enables complex database queries with dynamic conditions using `SupportBillDetailPageQueryImpl`. This allows for flexible data retrieval by constructing SQL queries programmatically based on various criteria and query types.

```kotlin
// Create query for paginated bill list
val queryCondition = TallyDataSourceSpi.Companion.BillQueryConditionDto(
    bookIdList = listOf("book456"),
    startTimeInclude = startTime,
    endTimeInclude = endTime,
    isDeleted = false,
    pageInfo = TallyDataSourceSpi.Companion.PageInfo(
        pageStartIndex = 0,
        pageSize = 20
    )
)

// Query types available
enum class BillDetailPageQueryType {
    DetailListDesc,  // Details sorted by time descending
    DetailListASC,   // Details sorted by time ascending
    DayTime,         // Group by day
    Count,           // Count query
    AmountList       // Sum amounts
}

// Execute raw query
val rawQuery = SupportBillDetailPageQueryImpl(
    queryType = BillDetailPageQueryType.DetailListDesc,
    queryCondition = queryCondition
)
val billDetails: List<BillDetailDo> = billDao.queryBillDetailList(rawQuery)
```

--------------------------------

### Manage User State with UserSpi in Kotlin

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Shows Kotlin code for accessing and managing user authentication state, including login status, user information, and VIP status using the UserSpi. It also covers retrieving the current token and required user info.

```kotlin
// Subscribe to login state
val isLoggedInFlow: Flow<Boolean> = userSpi.isLoginStateOb

// Subscribe to user info
val userInfoFlow: Flow<UserInfoDto?> = userSpi.userInfoStateOb

// Subscribe to VIP status
val isVipFlow: Flow<Boolean> = userSpi.isVipStateOb
val vipInfoFlow: Flow<UserVipResDto?> = userSpi.vipInfoStateOb

// Get current token
val token: String? = userSpi.userTokenNow

// Get required user info (throws NotLoggedInException)
val userInfo: UserInfoDto = userSpi.requiredUserInfo()

// Get last logged in user ID
val lastUserId: String = userSpi.requiredLastUserId()
```

--------------------------------

### Query Bill Details and Subscriptions

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Perform detailed bill queries using comprehensive conditions and subscribe to real-time updates for both bill lists and aggregated amounts. Supports filtering by book, type, category, date range, and amount.

```Kotlin
val queryCondition = TallyDataSourceSpi.Companion.BillQueryConditionDto(
    bookIdList = listOf("book456"),
    typeList = listOf(TallyBillDto.Type.NORMAL, TallyBillDto.Type.REFUND),
    categoryIdList = listOf("category789"),
    startTimeInclude = startOfMonth,
    endTimeInclude = endOfMonth,
    amountLessThanZero = true,  // Only expenses
    isDeleted = false,
    isNotCalculate = false,
    pageInfo = TallyDataSourceSpi.Companion.PageInfo(
        pageStartIndex = 0,
        pageSize = 20
    )
)

val billList: List<TallyBillDetailDto> = tallyDataSourceSpi.getBillDetailListByCondition(
    queryCondition = queryCondition
)

val billListFlow: Flow<List<TallyBillDetailDto>> = tallyDataSourceSpi.subscribeBillDetailList(
    queryCondition = queryCondition
)

val totalSpending: MoneyFen = tallyDataSourceSpi.getBillAmountByCondition(
    queryCondition = queryCondition
)

val amountFlow: Flow<MoneyFen> = tallyDataSourceSpi.subscribeBillAmountByCondition(
    queryCondition = queryCondition
)

val billCount: Long = tallyDataSourceSpi.getBillCountByCondition(
    queryCondition = queryCondition
)
```

--------------------------------

### Manage Hierarchical Categories

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Handle category creation, retrieval of child categories, and searching across all books. Supports hierarchical structures and subscribing to all categories within specified books.

```Kotlin
val categoryId: String = tallyDataSourceSpi.insertCategory(
    target = TallyCategoryInsertDto(
        userId = "user123",
        bookId = "book456",
        parentId = "parentCat123",  // Optional parent
        type = TallyCategoryDto.TYPE_SPENDING,
        name = "Transportation",
        iconName = "car1",
        sort = System.currentTimeMillis()
    ),
    isNeedSync = true
)

val categoriesFlow: Flow<List<TallyCategoryDto>> = tallyDataSourceSpi.subscribeAllCategory(
    bookIdList = listOf("book456")
)

val childCategories: List<TallyCategoryDto> = tallyDataSourceSpi.getCategoryByParentId(
    parentId = "parentCat123"
)

val searchResults: List<TallyCategoryDto> = tallyDataSourceSpi.searchCategory(key = "food")
```

--------------------------------

### TallyBookDto - Create and Use Account Book Data Models (Kotlin)

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Represents ledger books for managing accounts, categories, and bills. This snippet illustrates different book types and demonstrates creating a new book DTO as well as generating a default book for the open-source version.

```kotlin
// Book types
object BookTypes {
    const val TYPE_EMPTY = "empty"
    const val TYPE_NORMAL = "normal"
    const val TYPE_TRAVEL = "travel"
    const val TYPE_BUSINESS = "business"
    const val TYPE_PET = "pet"
}

// Creating a book
val bookInsert = TallyBookInsertDto(
    userId = "user123",
    isSystem = false,
    type = TallyBookDto.TYPE_NORMAL,
    name = "Personal Finance",
    iconName = "book1",
    timeCreate = System.currentTimeMillis()
)

// Default book for open source version
val defaultBook = TallyBookDto.createForOpenSource()
```

--------------------------------

### Direct Database Operations using Room for Bills

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Provides Data Access Object (DAO) interface for direct database operations on bill data using Room persistence library. It includes methods for retrieving, inserting, and updating bill details, as well as subscribing to sync status.

```kotlin
interface BillDao {
    // Get bill detail by ID
    @Transaction
    @Query("SELECT * FROM bill where id = :id")
    suspend fun getById(id: String): BillDetailDo?

    // Get latest bill by modification time
    @Query("SELECT * FROM bill WHERE bookId = :bookId ORDER BY timeModify DESC LIMIT 1")
    suspend fun getLatestOneOrderByTimeModify(bookId: String): BillDo?

    // Get unsynced bills
    @Query("SELECT * FROM bill WHERE bookId = :bookId AND isSync = 0 LIMIT :pageSize")
    suspend fun getUnSyncList(bookId: String, pageSize: Int): List<BillDo>

    // Insert or replace bill
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(target: BillDo)

    // Update bill
    @Update
    suspend fun update(target: BillDo)

    // Subscribe to sync count
    @Query("SELECT COUNT(id) FROM bill WHERE isSync = 1 AND isDeleted = 0")
    fun subscribeBillSyncSuccessCountExcludeDeleted(): Flow<Long>
}

// Usage example
val billDao = tallyDatabase.billDao()
val latestBill = billDao.getLatestOneOrderByTimeModify(bookId = "book456")
```

--------------------------------

### TallyBillDto - Create and Use Bill Data Models (Kotlin)

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Defines the structure for financial transactions (bills) including normal bills, transfers, and refunds. It shows how to create new bill DTOs, use bill type enumerations, and check refund permissions. Amounts are stored in cents (fen) for precision.

```kotlin
// Creating a new bill insert DTO
val billInsert = TallyBillInsertDto(
    userId = "user123",
    bookId = "book456",
    type = TallyBillDto.TYPE_NORMAL,  // "normal", "transfer", or "refund"
    time = System.currentTimeMillis(),
    categoryId = "category789",
    accountId = "account001",
    amount = -5000L,  // -50.00 yuan (negative for expenses)
    note = "Lunch at restaurant",
    isNotCalculate = false,  // Include in statistics
    isDeleted = false,
    isSync = false
)

// Bill types enumeration
val billType = TallyBillDto.Type.from("normal")  // Returns Type.NORMAL
val isRefundable = billDto.canRefundWithType  // true for NORMAL and TRANSFER types

// Check user refund permission
val canUserRefund = billDto.userCanRefund(targetUserId = "user123")
```

--------------------------------

### Database Operations with TallyDataSourceSpi in Kotlin

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Illustrates Kotlin code for subscribing to database table changes, performing transactional operations using a lambda, and clearing all data for a specific book via TallyDataSourceSpi.

```kotlin
// Subscribe to specific table changes
val tableChangesFlow: Flow<Unit> = tallyDataSourceSpi.subscribeDataBaseTableChangedOb(
    TallyTable.Bill,
    TallyTable.Category,
    TallyTable.Account,
    emitOneWhileSubscribe = true
)

// Perform operations in transaction
val result = tallyDataSourceSpi.withTransaction {
    val bookId = insertBookList(listOf(bookInsert)).first()
    insertOrUpdateCategoryList(categoryList)
    insertOrUpdateAccountList(accountList)
    bookId
}

// Clear all data for a book
tallyDataSourceSpi.clearAllDataByBookId(bookId = "book456")
```

--------------------------------

### Material Design 3 UI Theming in Jetpack Compose

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Implements UI theming using Material Design 3 color schemes. Provides composable functions for defining themes, including custom themes like 'China Red' and dynamic color schemes for Android 12+ devices.

```kotlin
// China Red Theme
@Composable
fun ChinaRedAppTheme(
    useDarkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable () -> Unit
) {
    val colors = if (!useDarkTheme) {
        ChinaRedLightColors  // lightColorScheme()
    } else {
        ChinaRedDarkColors   // darkColorScheme()
    }
    MaterialTheme(
        colorScheme = colors,
        content = content
    )
}

// Dynamic Color Theme (Android 12+)
@Composable
fun DynamicTheme(
    useDarkTheme: Boolean = isSystemInDarkTheme(),
    content: @Composable () -> Unit
) {
    val context = LocalContext.current
    val colors = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        if (useDarkTheme) dynamicDarkColorScheme(context)
        else dynamicLightColorScheme(context)
    } else {
        if (useDarkTheme) DefaultDarkColors else DefaultLightColors
    }
    MaterialTheme(colorScheme = colors, content = content)
}
```

--------------------------------

### Create, Update, and Retrieve Bills

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Manage individual bills through insert, update, and retrieval operations. Supports associating labels and images with bills, and subscribing to changes for specific bills.

```Kotlin
val newBillId: String = tallyDataSourceSpi.insertBill(
    target = TallyBillInsertDto(
        userId = "user123",
        bookId = "book456",
        type = TallyBillDto.TYPE_NORMAL,
        time = System.currentTimeMillis(),
        categoryId = "category789",
        accountId = "account001",
        amount = -3500L,  // -35.00 yuan
        note = "Coffee"
    ),
    labelIdList = listOf("label1", "label2"),
    imageUrlList = listOf("https://example.com/receipt.jpg"),
    isNeedSync = true
)

tallyDataSourceSpi.updateBill(
    target = existingBill.copy(
        amount = -4000L,
        note = "Updated note"
    ),
    labelIdList = listOf("label1"),
    imageUrlList = emptyList(),
    isNeedSync = true
)

val billDetail: TallyBillDetailDto? = tallyDataSourceSpi.getBillDetailById(id = "billId123")

val billDetailFlow: Flow<TallyBillDetailDto?> = tallyDataSourceSpi.subscribeBillDetailById(
    id = "billId123"
)
```

--------------------------------

### Centralized App Navigation Routes with AppRouterConfig

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Defines a centralized object `AppRouterConfig` for managing all application route definitions. This promotes consistency and simplifies navigation across different modules of the app.

```kotlin
object AppRouterConfig {
    // Base routes
    const val BASE_DATE_TIME_SELECT = "base/dateTimeSelect"
    const val BASE_BOTTOM_MENU_SELECT = "base/menuSelect"
    const val BASE_WEB = "base/web"

    // Main routes
    const val MAIN_MAIN = "main/main"
    const val MAIN_BILL = "main/bill"
    const val MAIN_CALENDAR = "main/calendar"
    const val MAIN_SETTING = "main/setting"
    const val MAIN_THEME_SELECT = "main/themeSelect"

    // User routes
    const val USER_LOGIN = "user/login"
    const val USER_MY = "user/my"
    const val USER_VIP_BUY = "user/vipBuy"

    // Core routes
    const val CORE_BILL_CURD = "core/billCrud"
    const val CORE_BILL_DETAIL = "core/billDetail"
    const val CORE_CATEGORY_SELECT = "core/categorySelect"
    const val CORE_ACCOUNT_SELECT = "core/accountSelect"
    const val CORE_BOOK_SWITCH = "core/bookSelect"
    const val CORE_AI_BILL_CHAT = "core/aiBillChat"
}

// Navigate using KComponent routing
AppRouterCoreApi::class.routeApi().toBillCrudView(
    context = context,
    billId = "bill123"  // Edit existing bill
)

AppRouterCoreApi::class.routeApi().toBillDetailView(
    context = context,
    billId = "bill123"
)
```

--------------------------------

### Manage Financial Accounts

Source: https://context7.com/xiaojinzi123/yike-app-common/llms.txt

Perform CRUD operations on financial accounts, including insertion, updating, and retrieval by ID. Supports searching accounts by a keyword and subscribing to all accounts within a specific book.

```Kotlin
val accountId: String = tallyDataSourceSpi.insertOrUpdateAccount(
    target = TallyAccountInsertDto(
        userId = "user123",
        bookId = "book456",
        iconName = "bank1",
        name = "Bank Account",
        balanceInit = 500000L,  // 5000.00 yuan
        isExcluded = false,
        isDefault = false
    ),
    isNeedSync = true
)

val accountsFlow: Flow<List<TallyAccountDto>> = tallyDataSourceSpi.subscribeAllAccount(
    bookId = "book456"
)

val account: TallyAccountDto? = tallyDataSourceSpi.getAccountById(id = "account001")

val searchResults: List<TallyAccountDto> = tallyDataSourceSpi.searchAccount(key = "bank")
```
Tokens:
Raw