path
stringlengths 4
280
| owner
stringlengths 2
39
| repo_id
int64 21.1k
879M
| is_fork
bool 2
classes | languages_distribution
stringlengths 13
1.95k
⌀ | content
stringlengths 7
482k
| issues
int64 0
13.9k
| main_language
stringclasses 121
values | forks
stringlengths 1
5
| stars
int64 0
111k
| commit_sha
stringlengths 40
40
| size
int64 7
482k
| name
stringlengths 1
100
| license
stringclasses 93
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
app/src/main/java/com/se7en/screentrack/viewmodels/AppDetailViewModel.kt | ashar-7 | 279,871,209 | false | null | package com.se7en.screentrack.viewmodels
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.se7en.screentrack.models.DayStats
import com.se7en.screentrack.models.SessionMinimal
import com.se7en.screentrack.repository.AppDetailRepository
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import org.threeten.bp.ZonedDateTime
import javax.inject.Inject
@HiltViewModel
class AppDetailViewModel @Inject constructor(
private val repository: AppDetailRepository
): ViewModel() {
val sessionsLiveData = MutableLiveData<List<SessionMinimal>>()
fun getDayStats(packageName: String): LiveData<List<DayStats>> {
return repository.getDayStats(packageName)
}
fun fetchSessions(packageName: String, date: ZonedDateTime) {
viewModelScope.launch {
sessionsLiveData.postValue(repository.getSessions(packageName, date))
}
}
}
| 1 | Kotlin | 0 | 21 | f899258b1e0aab3e2b0aa3f3e63d9a2b0299cfc9 | 1,021 | ScreenTrack-Android | The Unlicense |
3ds2/src/main/java/com/adyen/checkout/adyen3ds2/Adyen3DS2Delegate.kt | leandromagnabosco | 533,836,687 | false | null | /*
* Copyright (c) 2022 Adyen N.V.
*
* This file is open source and available under the MIT license. See the LICENSE file for more info.
*
* Created by oscars on 22/8/2022.
*/
package com.adyen.checkout.adyen3ds2
import com.adyen.checkout.components.base.ActionDelegate
import com.adyen.checkout.components.base.DetailsEmittingDelegate
import com.adyen.checkout.components.base.IntentHandlingDelegate
import com.adyen.checkout.components.model.payments.response.BaseThreeds2Action
import com.adyen.threeds2.customization.UiCustomization
interface Adyen3DS2Delegate :
ActionDelegate<BaseThreeds2Action>,
DetailsEmittingDelegate,
IntentHandlingDelegate {
fun set3DS2UICustomization(uiCustomization: UiCustomization?)
}
| 2 | Kotlin | 0 | 0 | c154e989a08f1dc76cf90f6949878621cbbfa644 | 743 | testsonarcloud | MIT License |
server/src/main/java/com/pyamsoft/tetherfi/server/proxy/session/udp/UdpProxyData.kt | pyamsoft | 475,225,784 | false | null | /*
* Copyright 2023 pyamsoft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.pyamsoft.tetherfi.server.proxy.session.udp
import com.pyamsoft.tetherfi.server.proxy.session.ProxyData
import io.ktor.network.sockets.Datagram
internal data class UdpProxyData
internal constructor(
internal val datagram: Datagram,
) : ProxyData
| 6 | null | 22 | 250 | eaa14e4b65a38fda60d4b301a08597d456233d46 | 856 | tetherfi | Apache License 2.0 |
src/main/kotlin/io/github/guttenbase/hints/impl/DefaultEntityTableCheckerHint.kt | guttenbase | 644,774,036 | false | {"Kotlin": 539819, "PLpgSQL": 271} | package io.github.guttenbase.hints.impl
import io.github.guttenbase.hints.EntityTableCheckerHint
import io.github.guttenbase.tools.EntityTableChecker
/**
* By default we check if the given table has an primary key column named "ID".
*
* © 2012-2034 akquinet tech@spree
*
*
* @author <NAME>
*/
open class DefaultEntityTableCheckerHint : EntityTableCheckerHint() {
override val value: EntityTableChecker
get() = EntityTableChecker { tableMetaData ->
for (columnMetaData in tableMetaData.columnMetaData) {
val columnName: String = columnMetaData.columnName.uppercase()
if (columnMetaData.isPrimaryKey && (columnName == "ID" || columnName == "IDENT")) {
return@EntityTableChecker true
}
}
false
}
}
| 0 | Kotlin | 0 | 1 | 109a053ad4bbeccf1356da68a7d2c3653cb67682 | 774 | guttenbase | Apache License 2.0 |
gradle-plugin/src/main/kotlin/app/softwork/serviceloader/CreateServiceLoadersResourcesFileTask.kt | hfhbd | 589,746,751 | false | null | package app.softwork.serviceloader
import org.gradle.api.*
import org.gradle.api.file.*
import org.gradle.api.provider.*
import org.gradle.api.tasks.*
import org.gradle.workers.*
import javax.inject.*
@CacheableTask
public abstract class CreateServiceLoadersResourcesFileTask : DefaultTask() {
@get:Input
public abstract val serviceLoaders: MapProperty<String, List<String>>
@get:InputFiles
@get:CompileClasspath
public abstract val classpath: ConfigurableFileCollection
@get:InputFiles
@get:CompileClasspath
public abstract val classes: ConfigurableFileCollection
@get:OutputDirectory
public abstract val resourcesDir: DirectoryProperty
init {
resourcesDir.convention(project.layout.buildDirectory.dir("generated/resources/serviceloader"))
}
@get:Inject
internal abstract val worker: WorkerExecutor
@TaskAction
internal fun create() {
val workQueue = worker.classLoaderIsolation {
classpath.from([email protected], classes)
}
for ((serviceLoader, classes) in serviceLoaders.get()) {
workQueue.submit(CreateServiceLoadersResourcesFileAction::class.java) {
this.serviceLoader.set(serviceLoader)
this.implementationClasses.set(classes)
this.resourcesDir.set([email protected]("META-INF/services"))
this.classes.setFrom([email protected])
}
}
}
}
| 1 | Kotlin | 0 | 3 | f767a4f39625a5b5c26f932c05a446f75cf859e5 | 1,570 | serviceloader-gradle-plugin | Apache License 2.0 |
extension/core/src/main/kotlin/io/holunda/camunda/bpm/correlate/correlation/CorrelationBatchResult.kt | holunda-io | 450,565,449 | false | {"Kotlin": 243470, "TypeScript": 20331, "Shell": 2838, "Dockerfile": 2012, "JavaScript": 1481, "CSS": 308} | package io.holunda.camunda.bpm.correlate.correlation
import io.holunda.camunda.bpm.correlate.correlation.metadata.MessageMetaData
/**
* Result of correlation.
*/
sealed interface CorrelationBatchResult {
/**
* Correlation success.
* @param successfulCorrelations successfully correlated messages.
*/
class Success(val successfulCorrelations: List<MessageMetaData>) : CorrelationBatchResult
/**
* Error during correlation of the batch.
* @param successfulCorrelations successfully correlated messages.
* @param errorCorrelations messages correlated with errors.
*/
class Error(val successfulCorrelations: List<MessageMetaData>, val errorCorrelations: Map<MessageMetaData, String>) : CorrelationBatchResult
}
| 6 | Kotlin | 2 | 9 | fad54870ef76440ff61412f390ba53d0cf970f88 | 741 | camunda-bpm-correlate | Apache License 2.0 |
temp/android-example/app/src/main/java/com/example/androidtodoapp/di/ApplicationModule.kt | vfa-trungnq | 310,345,984 | false | null | /*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.architecture.blueprints.todoapp.di
import android.content.Context
import androidx.room.Room
import com.example.android.architecture.blueprints.todoapp.data.source.DefaultTasksRepository
import com.example.android.architecture.blueprints.todoapp.data.source.TasksDataSource
import com.example.android.architecture.blueprints.todoapp.data.source.TasksRepository
import com.example.android.architecture.blueprints.todoapp.data.source.local.TasksLocalDataSource
import com.example.android.architecture.blueprints.todoapp.data.source.local.ToDoDatabase
import com.example.android.architecture.blueprints.todoapp.data.source.remote.TasksRemoteDataSource
import dagger.Binds
import dagger.Module
import dagger.Provides
import kotlinx.coroutines.CoroutineDispatcher
import kotlinx.coroutines.Dispatchers
import javax.inject.Qualifier
import javax.inject.Singleton
import kotlin.annotation.AnnotationRetention.RUNTIME
@Module(includes = [ApplicationModuleBinds::class])
object ApplicationModule {
@Qualifier
@Retention(RUNTIME)
annotation class TasksRemoteDataSource
@Qualifier
@Retention(RUNTIME)
annotation class TasksLocalDataSource
@JvmStatic
@Singleton
@TasksRemoteDataSource
@Provides
fun provideTasksRemoteDataSource(): TasksDataSource {
return TasksRemoteDataSource
}
@JvmStatic
@Singleton
@TasksLocalDataSource
@Provides
fun provideTasksLocalDataSource(database: ToDoDatabase, ioDispatcher: CoroutineDispatcher): TasksDataSource {
return TasksLocalDataSource(database.taskDao(), ioDispatcher)
}
@JvmStatic
@Singleton
@Provides
fun provideDataBase(context: Context): ToDoDatabase {
return Room.databaseBuilder(context.applicationContext, ToDoDatabase::class.java, "Tasks.db").build()
}
@JvmStatic
@Singleton
@Provides
fun provideIoDispatcher() = Dispatchers.IO
}
@Module
abstract class ApplicationModuleBinds {
@Singleton
@Binds
abstract fun bindRepository(repo: DefaultTasksRepository): TasksRepository
}
| 0 | Kotlin | 0 | 0 | d5b077c5be031453e66bc2cde1ec784615a2a6db | 2,709 | todo-app | Apache License 2.0 |
shared/accounts/account/src/main/java/ir/mehdiyari/krypt/account/data/repositories/AccountsRepository.kt | mehdiyari | 459,064,107 | false | {"Kotlin": 470699, "Java": 87170} | package ir.mehdiyari.krypt.account.data.repositories
interface AccountsRepository {
suspend fun addAccount(
name: String,
password: String,
passwordConfig: String
): Pair<Boolean, Throwable?>
suspend fun getAllAccountsName(): List<String>
suspend fun isAccountExists(): Boolean
suspend fun login(
accountName: String,
password: String
): Boolean
suspend fun validatePassword(
password: String
): Boolean
suspend fun deleteCurrentAccount()
} | 17 | Kotlin | 1 | 3 | 371bc18b7336a7a7256624039e216f4ea5944f77 | 532 | krypt | Apache License 2.0 |
app/src/main/java/com/consistence/pinyin/app/PinyinActivity.kt | nazarcybulskij | 141,337,468 | true | {"Kotlin": 105481} | package com.consistence.pinyin.app
import android.content.Context
import android.content.Intent
import android.os.Bundle
import android.support.v7.widget.SearchView
import com.consistence.pinyin.MxViewActivity
import com.consistence.pinyin.R
import com.consistence.pinyin.ViewModelFactory
import com.consistence.pinyin.app.list.PinyinListIntent
import com.consistence.pinyin.kit.gone
import com.consistence.pinyin.kit.visible
import com.jakewharton.rxbinding2.support.design.widget.RxTabLayout
import dagger.android.AndroidInjection
import io.reactivex.Observable
import kotlinx.android.synthetic.main.pinyin_activity.*
import javax.inject.Inject
class PinyinActivity(
override var currentSearchQuery: String = ""
) : MxViewActivity<PinyinIntent, PinyinRenderAction, PinyinViewState, PinyinLayout>(), PinyinLayout {
@Inject lateinit var viewModelFactory: ViewModelFactory<PinyinViewModel>
@Inject lateinit var render: PinyinRenderer
private lateinit var fragmentAdapter: PinyinFragmentAdapter
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.pinyin_activity)
fragmentAdapter = PinyinFragmentAdapter(
R.id.pinyin_activity_fragment_container,
pinyin_activity_tablayout,
supportFragmentManager,
this)
pinyin_activity_searchview.setOnQueryTextFocusChangeListener { _, hasFocus ->
if (hasFocus) {
pinyin_activity_searchview_label.gone()
}
}
pinyin_activity_searchview.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
override fun onQueryTextSubmit(p: String): Boolean { return false }
override fun onQueryTextChange(terms: String): Boolean {
currentSearchQuery = terms
sendSearchEvent(terms)
return true
}
})
pinyin_activity_searchview.setOnCloseListener {
sendSearchEvent()
pinyin_activity_searchview_label.visible()
false
}
pinyin_activity_searchview_label.setOnClickListener({
pinyin_activity_searchview.isIconified = false
})
}
override fun intents(): Observable<PinyinIntent> = Observable.merge(
Observable.just(PinyinIntent.Init),
RxTabLayout
.selectionEvents(pinyin_activity_tablayout)
.map({ PinyinIntent.TabSelected(Page.values()[it.tab().position]) })
)
private fun sendSearchEvent(terms: String = "") {
fragmentAdapter.sendIntent(PinyinListIntent.Search(terms))
}
override fun inject() {
AndroidInjection.inject(this)
}
override fun layout(): PinyinLayout = this
override fun model(): PinyinViewModel = getViewModel(viewModelFactory)
override fun render(): PinyinRenderer = render
override fun updateSearchHint(hint: String) {
pinyin_activity_searchview.queryHint = hint
pinyin_activity_searchview_label.text = hint
}
companion object { fun newIntent(context: Context) = Intent(context, PinyinActivity::class.java) }
} | 0 | Kotlin | 0 | 0 | b51f51d8de2aaf2c06deaf3a160ec9ddb2338b60 | 3,214 | android-mvi | Apache License 2.0 |
apollo-mockserver/src/jsMain/kotlin/com/apollographql/apollo3/mockserver/MockServer.kt | apollographql | 69,469,299 | false | null | package com.apollographql.apollo3.mockserver
import Buffer
import net.AddressInfo
import okio.ByteString.Companion.toByteString
import kotlin.coroutines.resume
import kotlin.coroutines.suspendCoroutine
actual class MockServer actual constructor(override val mockServerHandler: MockServerHandler) : MockServerInterface {
private val requests = mutableListOf<MockRequest>()
private var url: String? = null
private val server = http.createServer { req, res ->
val requestBody = StringBuilder()
req.on("data") { chunk ->
when (chunk) {
is String -> requestBody.append(chunk)
is Buffer -> requestBody.append(chunk.toString("utf8"))
else -> println("WTF")
}
}
req.on("end") { _ ->
val request = MockRequest(
req.method,
req.url,
req.httpVersion,
req.rawHeaders.toList().zipWithNext().toMap(),
requestBody.toString().encodeToByteArray().toByteString()
)
requests.add(request)
val mockResponse = try {
mockServerHandler.handle(request)
} catch (e: Exception) {
throw Exception("MockServerHandler.handle() threw an exception: ${e.message}", e)
}
res.statusCode = mockResponse.statusCode
mockResponse.headers.forEach {
res.setHeader(it.key, it.value)
}
res.end(mockResponse.body.utf8())
}
}.listen()
override suspend fun url() = url ?: suspendCoroutine { cont ->
url = "http://localhost:${server.address().unsafeCast<AddressInfo>().port}/"
server.on("listening") { _ ->
cont.resume(url!!)
}
}
override fun enqueue(mockResponse: MockResponse) {
(mockServerHandler as? QueueMockServerHandler)?.enqueue(mockResponse)
?: error("Apollo: cannot call MockServer.enqueue() with a custom handler")
}
override fun takeRequest(): MockRequest {
return requests.removeFirst()
}
override suspend fun stop() = suspendCoroutine<Unit> { cont ->
server.close {
cont.resume(Unit)
}
}
}
| 122 | null | 542 | 2,994 | ac10257283e1196c3feb0d8f1a3b5d9476ad681a | 2,029 | apollo-kotlin | MIT License |
sdk-media-webrtc/src/main/kotlin/com/pexip/sdk/media/webrtc/internal/WebRtcLocalVideoTrack.kt | pexip | 493,156,648 | false | null | /*
* Copyright 2022 Pexip AS
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.pexip.sdk.media.webrtc.internal
import android.content.Context
import com.pexip.sdk.media.LocalMediaTrack
import com.pexip.sdk.media.LocalVideoTrack
import com.pexip.sdk.media.QualityProfile
import com.pexip.sdk.media.VideoTrack
import org.webrtc.CapturerObserver
import org.webrtc.EglBase
import org.webrtc.SurfaceTextureHelper
import org.webrtc.VideoCapturer
import org.webrtc.VideoFrame
import org.webrtc.VideoSource
import java.util.concurrent.CopyOnWriteArraySet
import java.util.concurrent.Executor
import java.util.concurrent.atomic.AtomicBoolean
internal open class WebRtcLocalVideoTrack(
applicationContext: Context,
eglBase: EglBase?,
private val videoCapturer: VideoCapturer,
private val videoSource: VideoSource,
internal val videoTrack: org.webrtc.VideoTrack,
protected val workerExecutor: Executor,
protected val signalingExecutor: Executor,
) : LocalVideoTrack, VideoTrack by WebRtcVideoTrack(videoTrack) {
private val disposed = AtomicBoolean()
private val capturingListeners = CopyOnWriteArraySet<LocalMediaTrack.CapturingListener>()
private val textureHelper =
SurfaceTextureHelper.create("CaptureThread:${videoTrack.id()}", eglBase?.eglBaseContext)
private val capturerObserver = object : CapturerObserver {
override fun onCapturerStarted(success: Boolean) {
videoSource.capturerObserver.onCapturerStarted(success)
if (capturing == success) return
capturing = success
notify(success)
}
override fun onCapturerStopped() {
videoSource.capturerObserver.onCapturerStopped()
if (!capturing) return
capturing = false
notify(false)
}
override fun onFrameCaptured(frame: VideoFrame?) {
videoSource.capturerObserver.onFrameCaptured(frame)
}
private fun notify(capturing: Boolean) {
signalingExecutor.maybeExecute {
capturingListeners.forEach {
it.safeOnCapturing(capturing)
}
}
}
}
@Volatile
final override var capturing = false
private set
init {
workerExecutor.maybeExecute {
videoCapturer.initialize(textureHelper, applicationContext, capturerObserver)
}
}
override fun startCapture(profile: QualityProfile) {
workerExecutor.maybeExecute {
videoCapturer.startCapture(profile.width, profile.height, profile.fps)
}
}
override fun startCapture() {
startCapture(QualityProfile.Medium)
}
override fun stopCapture() {
workerExecutor.maybeExecute {
videoCapturer.stopCapture()
}
}
override fun registerCapturingListener(listener: LocalMediaTrack.CapturingListener) {
capturingListeners += listener
}
override fun unregisterCapturingListener(listener: LocalMediaTrack.CapturingListener) {
capturingListeners -= listener
}
override fun dispose() {
if (disposed.compareAndSet(false, true)) {
workerExecutor.execute {
videoCapturer.stopCapture()
videoTrack.dispose()
videoSource.dispose()
videoCapturer.dispose()
textureHelper.dispose()
}
}
}
}
| 3 | Kotlin | 1 | 5 | d05f4d526f4065444863a607b8038db3c7f71cfa | 3,970 | pexip-android-sdk | Apache License 2.0 |
src/main/kotlin/com/mairwunnx/projectessentials/spawn/configurations/SpawnConfiguration.kt | ProjectEssentials | 208,573,101 | false | null | package com.mairwunnx.projectessentials.spawn.configurations
import com.mairwunnx.projectessentials.core.api.v1.configuration.IConfiguration
import com.mairwunnx.projectessentials.core.api.v1.helpers.jsonInstance
import com.mairwunnx.projectessentials.core.api.v1.helpers.projectConfigDirectory
import com.mairwunnx.projectessentials.spawn.firstLaunch
import net.minecraftforge.fml.server.ServerLifecycleHooks
import org.apache.logging.log4j.LogManager
import java.io.File
import java.io.FileNotFoundException
object SpawnConfiguration : IConfiguration<SpawnConfigurationModel> {
private val logger = LogManager.getLogger()
private var configurationData = SpawnConfigurationModel()
override val name = "spawn"
override val version = 1
override val configuration = take()
override val path by lazy {
projectConfigDirectory + File.separator + ServerLifecycleHooks.getCurrentServer().folderName + File.separator + "spawn.json"
}
override fun load() {
try {
val configRaw = File(path).readText()
configurationData = jsonInstance.parse(
SpawnConfigurationModel.serializer(), configRaw
)
} catch (ex: FileNotFoundException) {
logger.error("Configuration file ($path) not found!")
logger.warn("The default configuration will be used")
firstLaunch = true
}
}
override fun save() {
File(path).parentFile.mkdirs()
logger.info("Saving configuration `${name}`")
val raw = jsonInstance.stringify(
SpawnConfigurationModel.serializer(), configurationData
)
try {
File(path).writeText(raw)
} catch (ex: SecurityException) {
logger.error("An error occurred while saving $name configuration", ex)
}
}
override fun take() = configurationData
}
| 0 | Kotlin | 1 | 2 | 2b8649b3d1f4e69530dbbf6cd370f25b32cd2d63 | 1,892 | ProjectEssentials-Spawn | MIT License |
app/src/main/java/com/green/china/model/Category.kt | khalidabdou | 389,423,017 | false | null | package com.green.china.model
import android.os.Parcelable
import androidx.room.Entity
import androidx.room.PrimaryKey
import com.google.gson.annotations.SerializedName
import com.green.china.utilities.Const
import kotlinx.android.parcel.Parcelize
@Parcelize
@Entity(tableName = Const.TABLE_CATEGORY)
data class Category(
@SerializedName("id", alternate = ["cid"])
@PrimaryKey
val id: Int,
@SerializedName("category_name", alternate = ["name"])
val name: String,
@SerializedName("category_image", alternate = ["image"])
val image: String,
val color: String,
var type:String?,
val total_wallpaper: String?
) : Parcelable
data class Categories(
@SerializedName("cats")
val listCategory: List<Category>
) | 0 | Kotlin | 0 | 0 | 87d0070b9cad2fdd949d56617ddf9b50b064f6d8 | 755 | GreenChina | Apache License 2.0 |
src/test/kotlin/org/rust/ide/inspections/RsTypeCheckInspectionStdTest.kt | garyttierney | 139,069,585 | true | {"Kotlin": 2600191, "Rust": 77368, "Lex": 18933, "HTML": 9582, "Shell": 760, "Java": 586, "RenderScript": 318} | /*
* Use of this source code is governed by the MIT license that can be
* found in the LICENSE file.
*/
package org.rust.ide.inspections
class RsTypeCheckInspectionStdTest : RsInspectionsTestBase(RsTypeCheckInspection(), true) {
// https://github.com/intellij-rust/intellij-rust/issues/2482
fun `test issue 2482`() = checkByText("""
fn main() {
let string: String = "string".to_owned();
}
""")
// https://github.com/intellij-rust/intellij-rust/issues/2460
fun `test issue 2460`() = checkByText("""
fn f64compare(x: &f64, y: &f64) -> ::std::cmp::Ordering {
x.partial_cmp(y).unwrap()
}
""")
}
| 0 | Kotlin | 0 | 0 | ab50600fe5fdec24dcdc1872a5ff4d8b8061dab4 | 677 | intellij-rust | MIT License |
features/goals/src/main/java/app/chamich/feature/goals/ui/GoalsPagerFragment.kt | Coinfo | 278,306,465 | false | {"Kotlin": 136112, "Ruby": 866} | /*
* Copyright (c) 2020 Chamich Apps. All rights reserved.
*/
package app.chamich.feature.goals.ui
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import androidx.lifecycle.ViewModelProvider
import androidx.navigation.findNavController
import app.chamich.feature.goals.R
import app.chamich.library.core.CorePagerFragment
import dagger.hilt.android.AndroidEntryPoint
// This fragment handles all navigation through the Goals functionality
@AndroidEntryPoint
class GoalsPagerFragment : CorePagerFragment() {
private var viewModel: GoalsPagerViewModel? = null
private var titleView: TextView? = null
////////////////////////////////////////////////////////////////////////////////////////////////
//region Fragment Override Functions
override fun onCreateView(
inflater: LayoutInflater, container: ViewGroup?,
savedInstanceState: Bundle?
): View? = inflater.inflate(R.layout.goals_container, container, false)
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewModel = ViewModelProvider(this).get(GoalsPagerViewModel::class.java)
titleView?.text = viewModel?.getDisplayedName() ?: ""
}
//endregion
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
//region CorePagerFragment Override Functions
override fun handleAddClicked() {
// Navigates to the Add Goals fragment
requireActivity().findNavController(
R.id.nav_host_fragment_goals
).navigate(R.id.destination_add_goal)
}
override fun setTitleView(view: TextView) {
titleView = view
titleView?.text = viewModel?.getDisplayedName() ?: ""
}
override fun getSubtitle(): String {
return "It's time to set the goal"
}
//endregion
////////////////////////////////////////////////////////////////////////////////////////////////
}
| 0 | Kotlin | 3 | 16 | 581bf4e4ff7e9cb5067bdf25e4e340b56ebaab92 | 2,181 | Perfectus | Apache License 2.0 |
src/main/kotlin/no/nav/k9/general/auth/TokenResolver.kt | navikt | 255,581,476 | false | null | package no.nav.k9.general.auth
import no.nav.helse.dusseldorf.ktor.auth.IdToken
import no.nav.helse.dusseldorf.oauth2.client.CachedAccessTokenClient
import org.slf4j.LoggerFactory
object TokenResolver {
private val logger = LoggerFactory.getLogger(TokenResolver::class.java)
fun resolveToken(
accessTokenClient: CachedAccessTokenClient,
idToken: IdToken,
scope: Set<String>
): IdToken = when {
idToken.issuerIsLoginservice() -> idToken
else -> {
val exchangeToken = IdToken(
accessTokenClient.getAccessToken(
scopes = scope,
onBehalfOf = idToken.value
).token
)
logger.info("Utvekslet token fra {} med token fra {}.", idToken.issuer(), exchangeToken.issuer())
exchangeToken
}
}
}
| 2 | Kotlin | 0 | 0 | bd6b5ff43b56a0c6a1eff2cb62b73e94efbdd54e | 867 | k9-ettersending-api | MIT License |
app/src/main/java/taiwan/no/one/dropbeat/core/cache/LruMemoryCache.kt | pokk | 263,073,196 | false | null | /*
* MIT License
*
* Copyright (c) 2020 SmashKs
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package taiwan.no.one.jurassicpark.core.cache
import androidx.collection.LruCache
import com.devrapid.kotlinshaver.LookUp
import com.google.gson.GsonBuilder
import java.util.Date
import taiwan.no.one.core.data.repostory.cache.local.MemoryCache
class LruMemoryCache(
private val lruCache: LruCache<String, LookUp<String>>
) : MemoryCache {
companion object Constant {
private const val KEY_TIMESTAMP = "time stamp"
private const val KEY_DATA = "data"
}
private val gson by lazy { GsonBuilder().create() }
override fun <RT> get(key: String, classOf: Class<RT>): Pair<Long, RT>? {
val map = lruCache.get(key) ?: return null
val timestamp = map[KEY_TIMESTAMP]?.toLong() ?: 0
return timestamp to gson.fromJson(map[KEY_DATA], classOf)
}
override fun put(key: String, value: Any?) {
if (value == null) return
lruCache.put(key, hashMapOf(
KEY_TIMESTAMP to Date().time.toString(),
KEY_DATA to gson.toJson(value),
))
}
}
| 1 | null | 2 | 12 | 0a44043e091fc697f4337eebde235efa33977a47 | 2,167 | DropBeat | MIT License |
domain/src/main/kotlin/no/nav/su/se/bakover/domain/søknadsbehandling/SøknadsbehandlingTilAttestering.kt | navikt | 227,366,088 | false | null | package no.nav.su.se.bakover.domain.søknadsbehandling
import arrow.core.Either
import arrow.core.left
import no.nav.su.se.bakover.common.ident.NavIdentBruker
import no.nav.su.se.bakover.common.person.Fnr
import no.nav.su.se.bakover.common.tid.Tidspunkt
import no.nav.su.se.bakover.common.tid.periode.Periode
import no.nav.su.se.bakover.domain.avkorting.AvkortingVedSøknadsbehandling
import no.nav.su.se.bakover.domain.behandling.Attestering
import no.nav.su.se.bakover.domain.behandling.Attesteringshistorikk
import no.nav.su.se.bakover.domain.behandling.AvslagGrunnetBeregning
import no.nav.su.se.bakover.domain.behandling.VurderAvslagGrunnetBeregning
import no.nav.su.se.bakover.domain.behandling.avslag.Avslagsgrunn
import no.nav.su.se.bakover.domain.behandling.avslag.Avslagsgrunn.Companion.toAvslagsgrunn
import no.nav.su.se.bakover.domain.beregning.Beregning
import no.nav.su.se.bakover.domain.grunnlag.EksterneGrunnlag
import no.nav.su.se.bakover.domain.grunnlag.EksterneGrunnlagSkatt
import no.nav.su.se.bakover.domain.grunnlag.Grunnlagsdata
import no.nav.su.se.bakover.domain.grunnlag.GrunnlagsdataOgVilkårsvurderinger
import no.nav.su.se.bakover.domain.oppdrag.simulering.Simulering
import no.nav.su.se.bakover.domain.oppgave.OppgaveId
import no.nav.su.se.bakover.domain.sak.Saksnummer
import no.nav.su.se.bakover.domain.sak.Sakstype
import no.nav.su.se.bakover.domain.søknad.Søknad
import no.nav.su.se.bakover.domain.søknadsbehandling.avslag.ErAvslag
import no.nav.su.se.bakover.domain.søknadsbehandling.stønadsperiode.Aldersvurdering
import no.nav.su.se.bakover.domain.søknadsbehandling.stønadsperiode.Stønadsperiode
import no.nav.su.se.bakover.domain.vilkår.Vilkårsvurderinger
import no.nav.su.se.bakover.domain.vilkår.Vilkårsvurderingsresultat
import java.util.UUID
sealed class SøknadsbehandlingTilAttestering : Søknadsbehandling() {
abstract override val saksbehandler: NavIdentBruker.Saksbehandler
abstract fun nyOppgaveId(nyOppgaveId: OppgaveId): SøknadsbehandlingTilAttestering
abstract fun tilUnderkjent(attestering: Attestering): UnderkjentSøknadsbehandling
abstract override val aldersvurdering: Aldersvurdering
abstract override val attesteringer: Attesteringshistorikk
abstract override val avkorting: AvkortingVedSøknadsbehandling.Vurdert
override fun leggTilSkatt(skatt: EksterneGrunnlagSkatt): Either<KunneIkkeLeggeTilSkattegrunnlag, Søknadsbehandling> =
KunneIkkeLeggeTilSkattegrunnlag.UgyldigTilstand.left()
data class Innvilget(
override val id: UUID,
override val opprettet: Tidspunkt,
override val sakId: UUID,
override val saksnummer: Saksnummer,
override val søknad: Søknad.Journalført.MedOppgave,
override val oppgaveId: OppgaveId,
override val fnr: Fnr,
override val beregning: Beregning,
override val simulering: Simulering,
override val saksbehandler: NavIdentBruker.Saksbehandler,
override val fritekstTilBrev: String,
override val aldersvurdering: Aldersvurdering,
override val grunnlagsdata: Grunnlagsdata,
override val vilkårsvurderinger: Vilkårsvurderinger.Søknadsbehandling,
override val eksterneGrunnlag: EksterneGrunnlag,
override val attesteringer: Attesteringshistorikk,
override val søknadsbehandlingsHistorikk: Søknadsbehandlingshistorikk,
override val sakstype: Sakstype,
override val avkorting: AvkortingVedSøknadsbehandling.KlarTilIverksetting,
) : SøknadsbehandlingTilAttestering() {
override val stønadsperiode: Stønadsperiode = aldersvurdering.stønadsperiode
override fun copyInternal(
stønadsperiode: Stønadsperiode,
grunnlagsdataOgVilkårsvurderinger: GrunnlagsdataOgVilkårsvurderinger.Søknadsbehandling,
søknadsbehandlingshistorikk: Søknadsbehandlingshistorikk,
aldersvurdering: Aldersvurdering,
): SøknadsbehandlingTilAttestering {
return copy(
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdataOgVilkårsvurderinger.grunnlagsdata,
vilkårsvurderinger = grunnlagsdataOgVilkårsvurderinger.vilkårsvurderinger,
eksterneGrunnlag = grunnlagsdataOgVilkårsvurderinger.eksterneGrunnlag,
søknadsbehandlingsHistorikk = søknadsbehandlingshistorikk,
)
}
override fun skalSendeVedtaksbrev(): Boolean {
return true
}
override val periode: Periode = aldersvurdering.stønadsperiode.periode
init {
kastHvisGrunnlagsdataOgVilkårsvurderingerPeriodenOgBehandlingensPerioderErUlike()
grunnlagsdata.kastHvisIkkeAlleBosituasjonerErFullstendig()
}
override fun accept(visitor: SøknadsbehandlingVisitor) {
visitor.visit(this)
}
override fun nyOppgaveId(nyOppgaveId: OppgaveId): Innvilget {
return this.copy(oppgaveId = nyOppgaveId)
}
override fun tilUnderkjent(attestering: Attestering): UnderkjentSøknadsbehandling.Innvilget {
return UnderkjentSøknadsbehandling.Innvilget(
id = id,
opprettet = opprettet,
sakId = sakId,
saksnummer = saksnummer,
søknad = søknad,
oppgaveId = oppgaveId,
fnr = fnr,
beregning = beregning,
simulering = simulering,
saksbehandler = saksbehandler,
attesteringer = attesteringer.leggTilNyAttestering(attestering),
søknadsbehandlingsHistorikk = søknadsbehandlingsHistorikk,
fritekstTilBrev = fritekstTilBrev,
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdata,
vilkårsvurderinger = vilkårsvurderinger,
eksterneGrunnlag = eksterneGrunnlag,
avkorting = avkorting,
sakstype = sakstype,
)
}
fun tilIverksatt(attestering: Attestering): IverksattSøknadsbehandling.Innvilget {
return IverksattSøknadsbehandling.Innvilget(
id = id,
opprettet = opprettet,
sakId = sakId,
saksnummer = saksnummer,
søknad = søknad,
oppgaveId = oppgaveId,
fnr = fnr,
beregning = beregning,
simulering = simulering,
saksbehandler = saksbehandler,
attesteringer = attesteringer.leggTilNyAttestering(attestering),
søknadsbehandlingsHistorikk = søknadsbehandlingsHistorikk,
fritekstTilBrev = fritekstTilBrev,
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdata,
vilkårsvurderinger = vilkårsvurderinger,
eksterneGrunnlag = eksterneGrunnlag,
avkorting = when (avkorting) {
is AvkortingVedSøknadsbehandling.IngenAvkorting -> avkorting
is AvkortingVedSøknadsbehandling.SkalAvkortes -> avkorting.avkort(id)
},
sakstype = sakstype,
)
}
}
sealed class Avslag : SøknadsbehandlingTilAttestering(), ErAvslag {
abstract override val aldersvurdering: Aldersvurdering
/** Ingenting og avkorte ved avslag. */
override val avkorting = AvkortingVedSøknadsbehandling.IngenAvkorting
fun iverksett(attestering: Attestering.Iverksatt): IverksattSøknadsbehandling.Avslag {
return when (this) {
is MedBeregning -> this.tilIverksatt(attestering)
is UtenBeregning -> this.tilIverksatt(attestering)
}
}
data class UtenBeregning(
override val id: UUID,
override val opprettet: Tidspunkt,
override val sakId: UUID,
override val saksnummer: Saksnummer,
override val søknad: Søknad.Journalført.MedOppgave,
override val oppgaveId: OppgaveId,
override val fnr: Fnr,
override val saksbehandler: NavIdentBruker.Saksbehandler,
override val fritekstTilBrev: String,
override val aldersvurdering: Aldersvurdering,
override val grunnlagsdata: Grunnlagsdata,
override val vilkårsvurderinger: Vilkårsvurderinger.Søknadsbehandling,
override val eksterneGrunnlag: EksterneGrunnlag,
override val attesteringer: Attesteringshistorikk,
override val søknadsbehandlingsHistorikk: Søknadsbehandlingshistorikk,
override val sakstype: Sakstype,
) : Avslag() {
override val stønadsperiode: Stønadsperiode = aldersvurdering.stønadsperiode
// TODO fiks typing/gyldig tilstand/vilkår fradrag?
override val avslagsgrunner: List<Avslagsgrunn> = when (val vilkår = vilkårsvurderinger.vurdering) {
is Vilkårsvurderingsresultat.Avslag -> vilkår.avslagsgrunner
is Vilkårsvurderingsresultat.Innvilget -> emptyList()
is Vilkårsvurderingsresultat.Uavklart -> emptyList()
}
override val periode: Periode = aldersvurdering.stønadsperiode.periode
override val beregning = null
override val simulering: Simulering? = null
init {
kastHvisGrunnlagsdataOgVilkårsvurderingerPeriodenOgBehandlingensPerioderErUlike()
}
override fun skalSendeVedtaksbrev(): Boolean {
return true
}
override fun accept(visitor: SøknadsbehandlingVisitor) {
visitor.visit(this)
}
override fun nyOppgaveId(nyOppgaveId: OppgaveId): UtenBeregning {
return this.copy(oppgaveId = nyOppgaveId)
}
override fun tilUnderkjent(attestering: Attestering): UnderkjentSøknadsbehandling.Avslag.UtenBeregning {
return UnderkjentSøknadsbehandling.Avslag.UtenBeregning(
id = id,
opprettet = opprettet,
sakId = sakId,
saksnummer = saksnummer,
søknad = søknad,
oppgaveId = oppgaveId,
fnr = fnr,
saksbehandler = saksbehandler,
attesteringer = attesteringer.leggTilNyAttestering(attestering),
søknadsbehandlingsHistorikk = søknadsbehandlingsHistorikk,
fritekstTilBrev = fritekstTilBrev,
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdata,
vilkårsvurderinger = vilkårsvurderinger,
eksterneGrunnlag = eksterneGrunnlag,
sakstype = sakstype,
)
}
override fun copyInternal(
stønadsperiode: Stønadsperiode,
grunnlagsdataOgVilkårsvurderinger: GrunnlagsdataOgVilkårsvurderinger.Søknadsbehandling,
søknadsbehandlingshistorikk: Søknadsbehandlingshistorikk,
aldersvurdering: Aldersvurdering,
): UtenBeregning {
return copy(
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdataOgVilkårsvurderinger.grunnlagsdata,
vilkårsvurderinger = grunnlagsdataOgVilkårsvurderinger.vilkårsvurderinger,
eksterneGrunnlag = grunnlagsdataOgVilkårsvurderinger.eksterneGrunnlag,
søknadsbehandlingsHistorikk = søknadsbehandlingshistorikk,
)
}
fun tilIverksatt(
attestering: Attestering,
): IverksattSøknadsbehandling.Avslag.UtenBeregning {
return IverksattSøknadsbehandling.Avslag.UtenBeregning(
id = id,
opprettet = opprettet,
sakId = sakId,
saksnummer = saksnummer,
søknad = søknad,
oppgaveId = oppgaveId,
fnr = fnr,
saksbehandler = saksbehandler,
attesteringer = attesteringer.leggTilNyAttestering(attestering),
søknadsbehandlingsHistorikk = søknadsbehandlingsHistorikk,
fritekstTilBrev = fritekstTilBrev,
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdata,
vilkårsvurderinger = vilkårsvurderinger,
eksterneGrunnlag = eksterneGrunnlag,
sakstype = sakstype,
)
}
}
data class MedBeregning(
override val id: UUID,
override val opprettet: Tidspunkt,
override val sakId: UUID,
override val saksnummer: Saksnummer,
override val søknad: Søknad.Journalført.MedOppgave,
override val oppgaveId: OppgaveId,
override val fnr: Fnr,
override val beregning: Beregning,
override val saksbehandler: NavIdentBruker.Saksbehandler,
override val fritekstTilBrev: String,
override val aldersvurdering: Aldersvurdering,
override val grunnlagsdata: Grunnlagsdata,
override val vilkårsvurderinger: Vilkårsvurderinger.Søknadsbehandling,
override val eksterneGrunnlag: EksterneGrunnlag,
override val attesteringer: Attesteringshistorikk,
override val søknadsbehandlingsHistorikk: Søknadsbehandlingshistorikk,
override val sakstype: Sakstype,
) : Avslag() {
override val stønadsperiode: Stønadsperiode = aldersvurdering.stønadsperiode
private val avslagsgrunnForBeregning: List<Avslagsgrunn> =
when (val vurdering = VurderAvslagGrunnetBeregning.vurderAvslagGrunnetBeregning(beregning)) {
is AvslagGrunnetBeregning.Ja -> listOf(vurdering.grunn.toAvslagsgrunn())
is AvslagGrunnetBeregning.Nei -> emptyList()
}
// TODO fiks typing/gyldig tilstand/vilkår fradrag?
override val avslagsgrunner: List<Avslagsgrunn> = when (val vilkår = vilkårsvurderinger.vurdering) {
is Vilkårsvurderingsresultat.Avslag -> vilkår.avslagsgrunner
is Vilkårsvurderingsresultat.Innvilget -> emptyList()
is Vilkårsvurderingsresultat.Uavklart -> emptyList()
} + avslagsgrunnForBeregning
override val periode: Periode = aldersvurdering.stønadsperiode.periode
override val simulering: Simulering? = null
init {
kastHvisGrunnlagsdataOgVilkårsvurderingerPeriodenOgBehandlingensPerioderErUlike()
grunnlagsdata.kastHvisIkkeAlleBosituasjonerErFullstendig()
}
override fun skalSendeVedtaksbrev(): Boolean {
return true
}
override fun accept(visitor: SøknadsbehandlingVisitor) {
visitor.visit(this)
}
override fun nyOppgaveId(nyOppgaveId: OppgaveId): MedBeregning {
return this.copy(oppgaveId = nyOppgaveId)
}
override fun tilUnderkjent(attestering: Attestering): UnderkjentSøknadsbehandling.Avslag.MedBeregning {
return UnderkjentSøknadsbehandling.Avslag.MedBeregning(
id = id,
opprettet = opprettet,
sakId = sakId,
saksnummer = saksnummer,
søknad = søknad,
oppgaveId = oppgaveId,
fnr = fnr,
beregning = beregning,
saksbehandler = saksbehandler,
attesteringer = attesteringer.leggTilNyAttestering(attestering),
søknadsbehandlingsHistorikk = søknadsbehandlingsHistorikk,
fritekstTilBrev = fritekstTilBrev,
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdata,
vilkårsvurderinger = vilkårsvurderinger,
eksterneGrunnlag = eksterneGrunnlag,
sakstype = sakstype,
)
}
override fun copyInternal(
stønadsperiode: Stønadsperiode,
grunnlagsdataOgVilkårsvurderinger: GrunnlagsdataOgVilkårsvurderinger.Søknadsbehandling,
søknadsbehandlingshistorikk: Søknadsbehandlingshistorikk,
aldersvurdering: Aldersvurdering,
): MedBeregning {
return copy(
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdataOgVilkårsvurderinger.grunnlagsdata,
vilkårsvurderinger = grunnlagsdataOgVilkårsvurderinger.vilkårsvurderinger,
eksterneGrunnlag = grunnlagsdataOgVilkårsvurderinger.eksterneGrunnlag,
søknadsbehandlingsHistorikk = søknadsbehandlingshistorikk,
)
}
internal fun tilIverksatt(
attestering: Attestering,
): IverksattSøknadsbehandling.Avslag.MedBeregning {
return IverksattSøknadsbehandling.Avslag.MedBeregning(
id = id,
opprettet = opprettet,
sakId = sakId,
saksnummer = saksnummer,
søknad = søknad,
oppgaveId = oppgaveId,
fnr = fnr,
beregning = beregning,
saksbehandler = saksbehandler,
attesteringer = attesteringer.leggTilNyAttestering(attestering),
søknadsbehandlingsHistorikk = søknadsbehandlingsHistorikk,
fritekstTilBrev = fritekstTilBrev,
aldersvurdering = aldersvurdering,
grunnlagsdata = grunnlagsdata,
vilkårsvurderinger = vilkårsvurderinger,
eksterneGrunnlag = eksterneGrunnlag,
sakstype = sakstype,
)
}
}
}
}
| 5 | Kotlin | 0 | 1 | 42b26070530b0b5a6bc2373ca3f4079465745cce | 18,401 | su-se-bakover | MIT License |
shared/data/actor/src/main/java/com/kennethss/movie/data/actor/ActorData.kt | KennethSS | 325,671,801 | false | null | package com.kennethss.movie.data.actor
import com.kennethss.movie.domain.movie.actor.Actor
data class ActorData(
val id: Int,
val name: String,
val profileUrl: String,
val character: String
)
fun ActorData.toDomain() = Actor(
id = id,
name = name,
profileUrl = profileUrl,
character = character
) | 0 | Kotlin | 2 | 9 | e72bcf9a3c7b63862e41787bf45f4991cefc27dd | 331 | Movie | Apache License 2.0 |
src/main/kotlin/top/focess/netdesign/ui/DefaultTheme.kt | MidCoard | 707,182,986 | false | {"Kotlin": 10287} | package top.focess.netdesign.ui
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material.Colors
import androidx.compose.material.darkColors
import androidx.compose.material.lightColors
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
object DefaultTheme {
val darkColors = darkColors(
primary = Color(0xFF1F1F1F), // Dark Charcoal Gray
primaryVariant = Color(0xFF191919), // Slightly Darker Charcoal Gray
secondary = Color(0xFFD32F2F), // Dark Red
secondaryVariant = Color(0xFFB71C1C), // Darker Red
background = Color(0xFF121212), // Dark Gray
surface = Color(0xFF333333), // Slightly lighter Gray
error = Color(0xFFFF5722), // Red
onPrimary = Color(0xFFFFFFFF), // White
onSecondary = Color(0xFFFFFFFF), // White
onBackground = Color(0xFFFFFFFF), // White
onSurface = Color(0xFFFFFFFF), // White
onError = Color(0xFFFFFFFF), // White
)
val lightColors = lightColors(
primary = Color(0xFFA5A5A5), // Light Gray
primaryVariant = Color(0xFF7E7E7E), // Slightly Darker Gray
secondary = Color(0xFFD32F2F), // Dark Red
secondaryVariant = Color(0xFFB71C1C), // Darker Red
background = Color(0xFFFFFFFF), // White
surface = Color(0xFFE0E0E0), // Light Gray
error = Color(0xFFFF5722), // Red
onPrimary = Color(0xFF000000), // Black
onSecondary = Color(0xFF000000), // Black
onBackground = Color(0xFF000000), // Black
onSurface = Color(0xFF000000), // Black
onError = Color(0xFFFFFFFF), // White
)
// @Composable
// fun colors() =
// if (isSystemInDarkTheme())
// darkColors
// else
// lightColors
@Composable
fun colors() = lightColors
} | 0 | Kotlin | 0 | 0 | 2881266a05fd0465cb266f30c08fc8a101bde12c | 1,968 | NetDesign2 | Apache License 2.0 |
src/main/kotlin/no/vingaas/pokermanager/repository/security/UserPermissionRepository.kt | tomandreaskv | 810,388,706 | false | {"Kotlin": 143404} | package no.vingaas.pokermanager.repository.security
import no.vingaas.pokermanager.entities.security.UserPermission
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.stereotype.Repository
@Repository
interface UserPermissionRepository : JpaRepository<UserPermission, Long>{
} | 0 | Kotlin | 0 | 1 | 76245f712deb230f6369d236fa6b440ac4e6553e | 315 | pokermanager-backend | Apache License 2.0 |
okhttp-urlconnection/src/main/kotlin/okhttp3/JavaNetAuthenticator.kt | square | 5,152,285 | false | null | /*
* Copyright (C) 2013 Square, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package okhttp3
import java.io.IOException
import okhttp3.Authenticator.Companion.JAVA_NET_AUTHENTICATOR
/**
* Do not use this.
*
* Instead, configure your OkHttpClient.Builder to use `Authenticator.JAVA_NET_AUTHENTICATOR`:
*
* ```
* val okHttpClient = OkHttpClient.Builder()
* .authenticator(okhttp3.Authenticator.Companion.JAVA_NET_AUTHENTICATOR)
* .build()
* ```
*/
@Deprecated(message = "Use okhttp3.Authenticator.Companion.JAVA_NET_AUTHENTICATOR instead")
class JavaNetAuthenticator : Authenticator {
@Throws(IOException::class)
override fun authenticate(
route: Route?,
response: Response,
): Request? = JAVA_NET_AUTHENTICATOR.authenticate(route, response)
}
| 2 | null | 9281 | 45,832 | dbedfd000c8e84bc914c619714b8c9bf7f3e06d4 | 1,302 | okhttp | Apache License 2.0 |
example/src/main/kotlin/course/infrastructure/adapter/out/projector/CourseProjectionAdminAdapter.kt | holixon | 751,579,530 | false | {"Kotlin": 133130, "JavaScript": 185} | package io.holixon.example.university.course.infrastructure.adapter.out.projector
import io.holixon.example.university.course.application.port.out.CourseProjectionAdminOutPort
import io.holixon.example.university.global.support.axon.ProcessorSupport
import mu.KLogging
import org.springframework.stereotype.Component
@Component
class CourseProjectionAdminAdapter(
private val courseProjectorRepository: CourseProjectorRepository,
private val processorSupport: ProcessorSupport
) : CourseProjectionAdminOutPort {
companion object: KLogging()
override fun resetCourseProjection() {
logger.info { "[COURSE ADMIN ADAPTER]: There are currently ${courseProjectorRepository.countAll()} courses available." }
logger.info { "[COURSE ADMIN ADAPTER]: Deleting courses from projection..." }
processorSupport.replay(CourseProjector.GROUP)
}
}
| 0 | Kotlin | 0 | 1 | 8ee881e3ca58daebb8e46e462f3dd8b787982f7b | 857 | axon-eclipse-store-projection-example | Apache License 2.0 |
kotest-framework/kotest-framework-engine/src/commonMain/kotlin/io/kotest/engine/lifecycle/invocation.kt | faloi | 392,782,647 | true | {"Kotlin": 2979581, "CSS": 352, "Java": 145} | package io.kotest.engine.events
import io.kotest.core.config.configuration
import io.kotest.core.config.testListeners
import io.kotest.core.spec.resolvedTestListeners
import io.kotest.core.test.TestCase
internal suspend fun TestCase.invokeBeforeInvocation(k: Int) {
val listeners = spec.resolvedTestListeners() + configuration.testListeners()
listeners.forEach {
it.beforeInvocation(this, k)
}
}
internal suspend fun TestCase.invokeAfterInvocation(k: Int) {
val listeners = spec.resolvedTestListeners() + configuration.testListeners()
listeners.forEach {
it.afterInvocation(this, k)
}
}
| 0 | null | 0 | 0 | 82f2caf85d48141d59dfd52646e5f8d932453911 | 620 | kotest | Apache License 2.0 |
app/src/main/java/eu/kanade/tachiyomi/ui/setting/eh/LanguagesDialog.kt | CrepeTF | 324,681,935 | true | {"Kotlin": 4172643} | package eu.kanade.tachiyomi.ui.setting.eh
import android.app.Dialog
import android.os.Bundle
import android.view.LayoutInflater
import android.widget.ScrollView
import com.bluelinelabs.conductor.ControllerChangeHandler
import com.bluelinelabs.conductor.ControllerChangeType
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import eu.kanade.tachiyomi.R
import eu.kanade.tachiyomi.data.preference.PreferencesHelper
import eu.kanade.tachiyomi.databinding.EhDialogLanguagesBinding
import eu.kanade.tachiyomi.ui.base.controller.DialogController
import eu.kanade.tachiyomi.ui.setting.SettingsEhController
import uy.kohesive.injekt.injectLazy
class LanguagesDialog(
bundle: Bundle? = null
) : DialogController(bundle) {
var binding: EhDialogLanguagesBinding? = null
private set
val preferences: PreferencesHelper by injectLazy()
override fun onCreateDialog(savedViewState: Bundle?): Dialog {
binding = EhDialogLanguagesBinding.inflate(LayoutInflater.from(activity!!))
val view = ScrollView(binding!!.root.context).apply {
addView(binding!!.root)
}
onViewCreated()
return MaterialAlertDialogBuilder(activity!!)
.setTitle(R.string.language_filtering)
.setMessage(R.string.language_filtering_summary)
.setView(view)
.setPositiveButton(android.R.string.ok) { _, _ ->
onPositive()
}
.setOnDismissListener {
onPositive()
}
.setOnCancelListener {
onPositive()
}
.setNegativeButton(android.R.string.cancel, null)
.create()
}
fun onViewCreated() {
val settingsLanguages = preferences.exhSettingsLanguages().get().split("\n")
val japanese = settingsLanguages[0].split("*").map { it.toBoolean() }
val english = settingsLanguages[1].split("*").map { it.toBoolean() }
val chinese = settingsLanguages[2].split("*").map { it.toBoolean() }
val dutch = settingsLanguages[3].split("*").map { it.toBoolean() }
val french = settingsLanguages[4].split("*").map { it.toBoolean() }
val german = settingsLanguages[5].split("*").map { it.toBoolean() }
val hungarian = settingsLanguages[6].split("*").map { it.toBoolean() }
val italian = settingsLanguages[7].split("*").map { it.toBoolean() }
val korean = settingsLanguages[8].split("*").map { it.toBoolean() }
val polish = settingsLanguages[9].split("*").map { it.toBoolean() }
val portuguese = settingsLanguages[10].split("*").map { it.toBoolean() }
val russian = settingsLanguages[11].split("*").map { it.toBoolean() }
val spanish = settingsLanguages[12].split("*").map { it.toBoolean() }
val thai = settingsLanguages[13].split("*").map { it.toBoolean() }
val vietnamese = settingsLanguages[14].split("*").map { it.toBoolean() }
val notAvailable =
settingsLanguages[15].split("*").map { it.toBoolean() }
val other = settingsLanguages[16].split("*").map { it.toBoolean() }
with(binding!!) {
japaneseOriginal.isChecked = japanese[0]
japaneseTranslated.isChecked = japanese[1]
japaneseRewrite.isChecked = japanese[2]
japaneseOriginal.isChecked = japanese[0]
japaneseTranslated.isChecked = japanese[1]
japaneseRewrite.isChecked = japanese[2]
englishOriginal.isChecked = english[0]
englishTranslated.isChecked = english[1]
englishRewrite.isChecked = english[2]
chineseOriginal.isChecked = chinese[0]
chineseTranslated.isChecked = chinese[1]
chineseRewrite.isChecked = chinese[2]
dutchOriginal.isChecked = dutch[0]
dutchTranslated.isChecked = dutch[1]
dutchRewrite.isChecked = dutch[2]
frenchOriginal.isChecked = french[0]
frenchTranslated.isChecked = french[1]
frenchRewrite.isChecked = french[2]
germanOriginal.isChecked = german[0]
germanTranslated.isChecked = german[1]
germanRewrite.isChecked = german[2]
hungarianOriginal.isChecked = hungarian[0]
hungarianTranslated.isChecked = hungarian[1]
hungarianRewrite.isChecked = hungarian[2]
italianOriginal.isChecked = italian[0]
italianTranslated.isChecked = italian[1]
italianRewrite.isChecked = italian[2]
koreanOriginal.isChecked = korean[0]
koreanTranslated.isChecked = korean[1]
koreanRewrite.isChecked = korean[2]
polishOriginal.isChecked = polish[0]
polishTranslated.isChecked = polish[1]
polishRewrite.isChecked = polish[2]
portugueseOriginal.isChecked = portuguese[0]
portugueseTranslated.isChecked = portuguese[1]
portugueseRewrite.isChecked = portuguese[2]
russianOriginal.isChecked = russian[0]
russianTranslated.isChecked = russian[1]
russianRewrite.isChecked = russian[2]
spanishOriginal.isChecked = spanish[0]
spanishTranslated.isChecked = spanish[1]
spanishRewrite.isChecked = spanish[2]
thaiOriginal.isChecked = thai[0]
thaiTranslated.isChecked = thai[1]
thaiRewrite.isChecked = thai[2]
vietnameseOriginal.isChecked = vietnamese[0]
vietnameseTranslated.isChecked = vietnamese[1]
vietnameseRewrite.isChecked = vietnamese[2]
notAvailableOriginal.isChecked = notAvailable[0]
notAvailableTranslated.isChecked = notAvailable[1]
notAvailableRewrite.isChecked = notAvailable[2]
otherOriginal.isChecked = other[0]
otherTranslated.isChecked = other[1]
otherRewrite.isChecked = other[2]
}
}
fun onPositive() {
val languages = with(binding!!) {
listOf(
"${japaneseOriginal.isChecked}*${japaneseTranslated.isChecked}*${japaneseRewrite.isChecked}",
"${englishOriginal.isChecked}*${englishTranslated.isChecked}*${englishRewrite.isChecked}",
"${chineseOriginal.isChecked}*${chineseTranslated.isChecked}*${chineseRewrite.isChecked}",
"${dutchOriginal.isChecked}*${dutchTranslated.isChecked}*${dutchRewrite.isChecked}",
"${frenchOriginal.isChecked}*${frenchTranslated.isChecked}*${frenchRewrite.isChecked}",
"${germanOriginal.isChecked}*${germanTranslated.isChecked}*${germanRewrite.isChecked}",
"${hungarianOriginal.isChecked}*${hungarianTranslated.isChecked}*${hungarianRewrite.isChecked}",
"${italianOriginal.isChecked}*${italianTranslated.isChecked}*${italianRewrite.isChecked}",
"${koreanOriginal.isChecked}*${koreanTranslated.isChecked}*${koreanRewrite.isChecked}",
"${polishOriginal.isChecked}*${polishTranslated.isChecked}*${polishRewrite.isChecked}",
"${portugueseOriginal.isChecked}*${portugueseTranslated.isChecked}*${portugueseRewrite.isChecked}",
"${russianOriginal.isChecked}*${russianTranslated.isChecked}*${russianRewrite.isChecked}",
"${spanishOriginal.isChecked}*${spanishTranslated.isChecked}*${spanishRewrite.isChecked}",
"${thaiOriginal.isChecked}*${thaiTranslated.isChecked}*${thaiRewrite.isChecked}",
"${vietnameseOriginal.isChecked}*${vietnameseTranslated.isChecked}*${vietnameseRewrite.isChecked}",
"${notAvailableOriginal.isChecked}*${notAvailableTranslated.isChecked}*${notAvailableRewrite.isChecked}",
"${otherOriginal.isChecked}*${otherTranslated.isChecked}*${otherRewrite.isChecked}"
).joinToString("\n")
}
preferences.exhSettingsLanguages().set(languages)
with(targetController as? SettingsEhController ?: return) {
preferences.exhSettingsLanguages().reconfigure()
}
}
override fun onChangeStarted(handler: ControllerChangeHandler, type: ControllerChangeType) {
super.onChangeStarted(handler, type)
if (!type.isEnter) {
binding = null
}
}
}
| 86 | Kotlin | 42 | 41 | 1f1137a1731af37b9199a21067a6e07dce477ebb | 8,374 | Takoyomi | Apache License 2.0 |
components/membership/membership-persistence-service-impl/src/integrationTest/kotlin/net/corda/membership/impl/persistence/service/MembershipPersistenceTest.kt | corda | 346,070,752 | false | null | package net.corda.membership.impl.persistence.service
import com.typesafe.config.ConfigFactory
import net.corda.configuration.read.ConfigurationReadService
import net.corda.crypto.cipher.suite.KeyEncodingService
import net.corda.data.CordaAvroDeserializer
import net.corda.data.CordaAvroSerializationFactory
import net.corda.data.CordaAvroSerializer
import net.corda.data.KeyValuePair
import net.corda.data.KeyValuePairList
import net.corda.data.config.Configuration
import net.corda.data.config.ConfigurationSchemaVersion
import net.corda.data.crypto.wire.CryptoSignatureWithKey
import net.corda.data.membership.common.ApprovalRuleDetails
import net.corda.data.membership.common.ApprovalRuleType
import net.corda.data.membership.common.RegistrationStatus
import net.corda.db.admin.LiquibaseSchemaMigrator
import net.corda.db.connection.manager.DbConnectionManager
import net.corda.db.connection.manager.VirtualNodeDbType
import net.corda.db.core.DbPrivilege
import net.corda.db.messagebus.testkit.DBSetup
import net.corda.db.schema.CordaDb
import net.corda.db.schema.DbSchema
import net.corda.db.testkit.DatabaseInstaller
import net.corda.db.testkit.TestDbInfo
import net.corda.layeredpropertymap.LayeredPropertyMapFactory
import net.corda.layeredpropertymap.create
import net.corda.libs.configuration.SmartConfigFactory
import net.corda.libs.configuration.datamodel.ConfigurationEntities
import net.corda.libs.packaging.core.CpiIdentifier
import net.corda.lifecycle.Lifecycle
import net.corda.lifecycle.LifecycleCoordinatorFactory
import net.corda.lifecycle.LifecycleCoordinatorName
import net.corda.lifecycle.LifecycleStatus
import net.corda.lifecycle.RegistrationStatusChangeEvent
import net.corda.lifecycle.StartEvent
import net.corda.lifecycle.createCoordinator
import net.corda.membership.datamodel.ApprovalRulesEntity
import net.corda.membership.datamodel.ApprovalRulesEntityPrimaryKey
import net.corda.membership.datamodel.GroupParametersEntity
import net.corda.membership.datamodel.MemberInfoEntity
import net.corda.membership.datamodel.MemberInfoEntityPrimaryKey
import net.corda.membership.datamodel.MembershipEntities
import net.corda.membership.datamodel.RegistrationRequestEntity
import net.corda.membership.impl.persistence.service.dummy.TestVirtualNodeInfoReadService
import net.corda.membership.lib.MemberInfoExtension.Companion.GROUP_ID
import net.corda.membership.lib.MemberInfoExtension.Companion.MEMBER_STATUS_ACTIVE
import net.corda.membership.lib.MemberInfoExtension.Companion.MEMBER_STATUS_DECLINED
import net.corda.membership.lib.MemberInfoExtension.Companion.MEMBER_STATUS_PENDING
import net.corda.membership.lib.MemberInfoExtension.Companion.PARTY_NAME
import net.corda.membership.lib.MemberInfoExtension.Companion.PLATFORM_VERSION
import net.corda.membership.lib.MemberInfoExtension.Companion.PROTOCOL_VERSION
import net.corda.membership.lib.MemberInfoExtension.Companion.SERIAL
import net.corda.membership.lib.MemberInfoExtension.Companion.SOFTWARE_VERSION
import net.corda.membership.lib.MemberInfoExtension.Companion.STATUS
import net.corda.membership.lib.MemberInfoExtension.Companion.URL_KEY
import net.corda.membership.lib.MemberInfoExtension.Companion.groupId
import net.corda.membership.lib.MemberInfoExtension.Companion.status
import net.corda.membership.lib.MemberInfoFactory
import net.corda.membership.lib.approval.ApprovalRuleParams
import net.corda.membership.lib.registration.RegistrationRequest
import net.corda.membership.lib.toMap
import net.corda.membership.lib.toSortedMap
import net.corda.membership.mtls.allowed.list.service.AllowedCertificatesReaderWriterService
import net.corda.membership.persistence.client.MembershipPersistenceClient
import net.corda.membership.persistence.client.MembershipPersistenceResult
import net.corda.membership.persistence.client.MembershipQueryClient
import net.corda.membership.persistence.service.MembershipPersistenceService
import net.corda.messaging.api.publisher.config.PublisherConfig
import net.corda.messaging.api.publisher.factory.PublisherFactory
import net.corda.messaging.api.records.Record
import net.corda.orm.EntityManagerFactoryFactory
import net.corda.orm.JpaEntitiesRegistry
import net.corda.orm.utils.transaction
import net.corda.orm.utils.use
import net.corda.schema.Schemas
import net.corda.schema.configuration.BootConfig.INSTANCE_ID
import net.corda.schema.configuration.ConfigKeys
import net.corda.schema.configuration.MessagingConfig.Bus.BUS_TYPE
import net.corda.test.util.TestRandom
import net.corda.test.util.eventually
import net.corda.test.util.identity.createTestHoldingIdentity
import net.corda.test.util.time.TestClock
import net.corda.v5.base.types.LayeredPropertyMap
import net.corda.v5.base.types.MemberX500Name
import net.corda.v5.base.util.seconds
import net.corda.v5.crypto.calculateHash
import net.corda.v5.membership.GroupParameters
import net.corda.v5.membership.MemberInfo
import net.corda.v5.membership.NotaryInfo
import net.corda.virtualnode.HoldingIdentity
import net.corda.virtualnode.VirtualNodeInfo
import org.assertj.core.api.Assertions.assertThat
import org.assertj.core.api.Assertions.fail
import org.bouncycastle.jce.provider.BouncyCastleProvider
import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertDoesNotThrow
import org.junit.jupiter.api.extension.ExtendWith
import org.osgi.test.common.annotation.InjectService
import org.osgi.test.junit5.service.ServiceExtension
import org.slf4j.LoggerFactory
import java.nio.ByteBuffer
import java.security.KeyPairGenerator
import java.time.Instant
import java.util.UUID
import java.util.UUID.randomUUID
import javax.persistence.EntityManagerFactory
@ExtendWith(ServiceExtension::class, DBSetup::class)
class MembershipPersistenceTest {
companion object {
private const val EPOCH_KEY = "corda.epoch"
private const val MPV_KEY = "corda.minimumPlatformVersion"
private const val MODIFIED_TIME_KEY = "corda.modifiedTime"
private const val RULE_ID = "rule-id"
private const val RULE_REGEX = "rule-regex"
private const val RULE_LABEL = "rule-label"
private val logger = LoggerFactory.getLogger(this::class.java.enclosingClass)
private const val BOOT_CONFIG_STRING = """
$INSTANCE_ID = 1
$BUS_TYPE = INMEMORY
"""
private const val MEMBER_CONTEXT_KEY = "key"
private const val MEMBER_CONTEXT_VALUE = "value"
private const val messagingConf = """
componentVersion="5.1"
subscription {
consumer {
close.timeout = 6000
poll.timeout = 6000
thread.stop.timeout = 6000
processor.retries = 3
subscribe.retries = 3
commit.retries = 3
}
producer {
close.timeout = 6000
}
}
"""
private val schemaVersion = ConfigurationSchemaVersion(1, 0)
@InjectService(timeout = 5000)
lateinit var publisherFactory: PublisherFactory
@InjectService(timeout = 5000)
lateinit var entityManagerFactoryFactory: EntityManagerFactoryFactory
@InjectService(timeout = 5000)
lateinit var lbm: LiquibaseSchemaMigrator
@InjectService(timeout = 5000)
lateinit var entitiesRegistry: JpaEntitiesRegistry
@InjectService(timeout = 5000)
lateinit var memberInfoFactory: MemberInfoFactory
@InjectService(timeout = 5000)
lateinit var membershipPersistenceService: MembershipPersistenceService
@InjectService(timeout = 5000)
lateinit var membershipPersistenceClient: MembershipPersistenceClient
@InjectService(timeout = 5000)
lateinit var membershipQueryClient: MembershipQueryClient
@InjectService(timeout = 5000)
lateinit var configurationReadService: ConfigurationReadService
@InjectService(timeout = 5000)
lateinit var dbConnectionManager: DbConnectionManager
@InjectService(timeout = 5000)
lateinit var lifecycleCoordinatorFactory: LifecycleCoordinatorFactory
@InjectService(timeout = 5000)
lateinit var cordaAvroSerializationFactory: CordaAvroSerializationFactory
@InjectService(timeout = 5000)
lateinit var virtualNodeReadService: TestVirtualNodeInfoReadService
@InjectService(timeout = 5000)
lateinit var layeredPropertyMapFactory: LayeredPropertyMapFactory
@InjectService(timeout = 5000)
lateinit var allowedCertificatesReaderWriterService: AllowedCertificatesReaderWriterService
@InjectService(timeout = 5000)
lateinit var keyEncodingService: KeyEncodingService
/**
* Wrapper class which allows the client to wait until the underlying DB message bus has been set up correctly with partitions required.
* Without this the client often tries to send RPC requests before the service has set up the kafka topics required
* for the DB message bus.
*/
val membershipPersistenceClientWrapper = object : MembershipPersistenceClient {
override fun persistMemberInfo(
viewOwningIdentity: HoldingIdentity,
memberInfos: Collection<MemberInfo>
) = safeCall {
membershipPersistenceClient.persistMemberInfo(viewOwningIdentity, memberInfos)
}
override fun persistGroupPolicy(
viewOwningIdentity: HoldingIdentity,
groupPolicy: LayeredPropertyMap,
) = safeCall {
membershipPersistenceClient.persistGroupPolicy(viewOwningIdentity, groupPolicy)
}
override fun persistGroupParameters(
viewOwningIdentity: HoldingIdentity,
groupParameters: GroupParameters
) = safeCall {
membershipPersistenceClient.persistGroupParameters(viewOwningIdentity, groupParameters)
}
override fun persistGroupParametersInitialSnapshot(
viewOwningIdentity: HoldingIdentity
) = safeCall {
membershipPersistenceClient.persistGroupParametersInitialSnapshot(viewOwningIdentity)
}
override fun addNotaryToGroupParameters(
viewOwningIdentity: HoldingIdentity,
notary: MemberInfo
) = safeCall {
membershipPersistenceClient.addNotaryToGroupParameters(viewOwningIdentity, notary)
}
override fun persistRegistrationRequest(
viewOwningIdentity: HoldingIdentity,
registrationRequest: RegistrationRequest
) = safeCall {
membershipPersistenceClient.persistRegistrationRequest(viewOwningIdentity, registrationRequest)
}
override fun setMemberAndRegistrationRequestAsApproved(
viewOwningIdentity: HoldingIdentity,
approvedMember: HoldingIdentity,
registrationRequestId: String,
) = safeCall {
membershipPersistenceClient.setMemberAndRegistrationRequestAsApproved(
viewOwningIdentity, approvedMember, registrationRequestId
)
}
override fun setMemberAndRegistrationRequestAsDeclined(
viewOwningIdentity: HoldingIdentity,
declinedMember: HoldingIdentity,
registrationRequestId: String
) = safeCall {
membershipPersistenceClient.setMemberAndRegistrationRequestAsDeclined(
viewOwningIdentity, declinedMember, registrationRequestId
)
}
override fun setRegistrationRequestStatus(
viewOwningIdentity: HoldingIdentity,
registrationId: String,
registrationRequestStatus: RegistrationStatus
) = safeCall {
membershipPersistenceClient.setRegistrationRequestStatus(
viewOwningIdentity, registrationId, registrationRequestStatus
)
}
override fun mutualTlsAddCertificateToAllowedList(
mgmHoldingIdentity: HoldingIdentity,
subject: String,
) = safeCall {
membershipPersistenceClient.mutualTlsAddCertificateToAllowedList(
mgmHoldingIdentity, subject
)
}
override fun mutualTlsRemoveCertificateFromAllowedList(
mgmHoldingIdentity: HoldingIdentity,
subject: String,
) = safeCall {
membershipPersistenceClient.mutualTlsRemoveCertificateFromAllowedList(
mgmHoldingIdentity, subject
)
}
override fun generatePreAuthToken(
mgmHoldingIdentity: HoldingIdentity,
preAuthTokenId: UUID,
ownerX500Name: MemberX500Name,
ttl: Instant?,
remarks: String?
)= safeCall {
membershipPersistenceClient.generatePreAuthToken(
mgmHoldingIdentity, preAuthTokenId, ownerX500Name, ttl, remarks
)
}
override fun revokePreAuthToken(
mgmHoldingIdentity: HoldingIdentity,
preAuthTokenId: UUID,
remarks: String?
) = safeCall {
membershipPersistenceClient.revokePreAuthToken(mgmHoldingIdentity, preAuthTokenId, remarks)
}
override fun addApprovalRule(
viewOwningIdentity: HoldingIdentity,
ruleParams: ApprovalRuleParams
) = safeCall {
membershipPersistenceClient.addApprovalRule(
viewOwningIdentity, ruleParams
)
}
override fun deleteApprovalRule(
viewOwningIdentity: HoldingIdentity,
ruleId: String,
ruleType: ApprovalRuleType
) = safeCall {
membershipPersistenceClient.deleteApprovalRule(
viewOwningIdentity, ruleId, ruleType
)
}
fun <T> safeCall(func: () -> T): T {
return eventually {
assertDoesNotThrow {
func()
}
}
}
override val isRunning get() = membershipPersistenceClient.isRunning
override fun start() = membershipPersistenceClient.start()
override fun stop() = membershipPersistenceClient.stop()
}
private val clock = TestClock(Instant.ofEpochSecond(0))
private val groupId = randomUUID().toString()
private val x500Name = MemberX500Name.parse("O=Alice, C=GB, L=London")
private val viewOwningHoldingIdentity = HoldingIdentity(x500Name, groupId)
private val holdingIdentityShortHash = viewOwningHoldingIdentity.shortHash
private val registeringX500Name = MemberX500Name.parse("O=Bob, C=GB, L=London")
private val registeringHoldingIdentity = HoldingIdentity(registeringX500Name, groupId)
private val vnodeDbInfo = TestDbInfo(VirtualNodeDbType.VAULT.getConnectionName(holdingIdentityShortHash), DbSchema.VNODE)
// private val vnodeDbInfo = TestDbInfo("vnode_vault_$holdingIdentityShortHash", DbSchema.VNODE)
private val clusterDbInfo = TestDbInfo.createConfig()
private val smartConfigFactory = SmartConfigFactory.createWithoutSecurityServices()
private val bootConfig = smartConfigFactory.create(ConfigFactory.parseString(BOOT_CONFIG_STRING))
private val dbConfig = smartConfigFactory.create(clusterDbInfo.config)
private lateinit var vnodeEmf: EntityManagerFactory
private lateinit var cordaAvroSerializer: CordaAvroSerializer<KeyValuePairList>
private lateinit var cordaAvroDeserializer: CordaAvroDeserializer<KeyValuePairList>
@JvmStatic
@BeforeAll
fun setUp() {
val coordinator = lifecycleCoordinatorFactory.createCoordinator<MembershipPersistenceTest> { e, c ->
when (e) {
is StartEvent -> {
logger.info("Starting test coordinator")
c.followStatusChangesByName(
setOf(
LifecycleCoordinatorName.forComponent<ConfigurationReadService>(),
LifecycleCoordinatorName.forComponent<DbConnectionManager>(),
LifecycleCoordinatorName.forComponent<MembershipPersistenceService>(),
)
)
}
is RegistrationStatusChangeEvent -> {
logger.info("Test coordinator is ${e.status}")
c.updateStatus(e.status)
}
else -> {
logger.info("Received and ignored event $e.")
}
}
}
coordinator.start()
cordaAvroSerializer = cordaAvroSerializationFactory.createAvroSerializer { }
cordaAvroDeserializer =
cordaAvroSerializationFactory.createAvroDeserializer({ }, KeyValuePairList::class.java)
val dbInstaller = DatabaseInstaller(entityManagerFactoryFactory, lbm, entitiesRegistry)
vnodeEmf = dbInstaller.setupDatabase(vnodeDbInfo, "vnode-vault", MembershipEntities.classes)
dbInstaller.setupClusterDatabase(clusterDbInfo, "config", ConfigurationEntities.classes).close()
entitiesRegistry.register(CordaDb.Vault.persistenceUnitName, MembershipEntities.classes)
setupConfig()
dbConnectionManager.startAndWait()
dbConnectionManager.bootstrap(dbConfig)
virtualNodeReadService.startAndWait()
membershipPersistenceService.startAndWait()
membershipPersistenceClientWrapper.startAndWait()
allowedCertificatesReaderWriterService.start()
eventually {
logger.info("Waiting for required services to start...")
assertEquals(LifecycleStatus.UP, coordinator.status)
logger.info("Required services started.")
}
val connectionID = dbConnectionManager.putConnection(
name = vnodeDbInfo.name,
privilege = DbPrivilege.DML,
config = vnodeDbInfo.config,
description = null,
updateActor = "sa"
)
val vnodeInfo = VirtualNodeInfo(
viewOwningHoldingIdentity,
CpiIdentifier("PLACEHOLDER", "PLACEHOLDER", TestRandom.secureHash()),
vaultDmlConnectionId = connectionID,
cryptoDmlConnectionId = connectionID,
uniquenessDmlConnectionId = connectionID,
timestamp = clock.instant()
)
virtualNodeReadService.putVNodeInfo(vnodeInfo)
}
@AfterAll
@JvmStatic
fun cleanup() {
if (Companion::vnodeEmf.isInitialized) {
vnodeEmf.close()
}
configurationReadService.stop()
dbConnectionManager.stop()
membershipPersistenceService.stop()
membershipPersistenceClientWrapper.stop()
virtualNodeReadService.stop()
}
private fun setupConfig() {
val publisher = publisherFactory.createPublisher(PublisherConfig("clientId"), bootConfig)
publisher.publish(
listOf(
Record(
Schemas.Config.CONFIG_TOPIC,
ConfigKeys.MESSAGING_CONFIG,
Configuration(messagingConf, messagingConf, 0, schemaVersion)
)
)
)
configurationReadService.startAndWait()
configurationReadService.bootstrapConfig(bootConfig)
}
private fun Lifecycle.startAndWait() {
start()
eventually(5.seconds) {
assertTrue(isRunning)
}
}
}
@Test
fun `registration requests can persist over RPC topic`() {
val registrationId = randomUUID().toString()
val status = RegistrationStatus.SENT_TO_MGM
val result = membershipPersistenceClientWrapper.persistRegistrationRequest(
viewOwningHoldingIdentity,
RegistrationRequest(
RegistrationStatus.SENT_TO_MGM,
registrationId,
registeringHoldingIdentity,
ByteBuffer.wrap(
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(MEMBER_CONTEXT_KEY, MEMBER_CONTEXT_VALUE)
)
)
)
),
CryptoSignatureWithKey(
ByteBuffer.wrap(byteArrayOf()),
ByteBuffer.wrap(byteArrayOf()),
KeyValuePairList(emptyList()),
),
)
)
assertThat(result).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val persistedEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(persistedEntity).isNotNull
assertThat(persistedEntity.registrationId).isEqualTo(registrationId)
assertThat(persistedEntity.holdingIdentityShortHash).isEqualTo(registeringHoldingIdentity.shortHash.value)
assertThat(persistedEntity.status).isEqualTo(status.toString())
val persistedMemberContext = persistedEntity.context.deserializeContextAsMap()
with(persistedMemberContext.entries) {
assertThat(size).isEqualTo(1)
assertThat(first().key).isEqualTo(MEMBER_CONTEXT_KEY)
assertThat(first().value).isEqualTo(MEMBER_CONTEXT_VALUE)
}
}
@Test
fun `persistGroupPolicy will increase the version every persistance`() {
val groupPolicy1 = layeredPropertyMapFactory.createMap(mapOf("aa" to "BBB"))
val persisted1 = membershipPersistenceClientWrapper.persistGroupPolicy(viewOwningHoldingIdentity, groupPolicy1)
assertThat(persisted1).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val version1 = (persisted1 as? MembershipPersistenceResult.Success<Int>)?.payload !!
val groupPolicy2 = layeredPropertyMapFactory.createMap(mapOf("aa" to "BBB1"))
val persisted2 = membershipPersistenceClientWrapper.persistGroupPolicy(viewOwningHoldingIdentity, groupPolicy2)
assertThat(persisted2).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val version2 = (persisted2 as? MembershipPersistenceResult.Success<Int>)?.payload
assertThat(version2).isEqualTo(version1 + 1)
}
@Test
fun `persistGroupParametersInitialSnapshot can persist over RPC topic`() {
vnodeEmf.transaction {
it.createQuery("DELETE FROM GroupParametersEntity").executeUpdate()
}
val persisted = membershipPersistenceClientWrapper.persistGroupParametersInitialSnapshot(viewOwningHoldingIdentity)
assertThat(persisted).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val persistedEntity = vnodeEmf.use {
it.find(
GroupParametersEntity::class.java,
1
)
}
assertThat(persistedEntity).isNotNull
assertThat(persistedEntity.epoch).isEqualTo(1)
with(persistedEntity.parameters) {
val deserialized = cordaAvroDeserializer.deserialize(this)!!.toMap()
assertThat(deserialized.size).isEqualTo(3)
assertThat(deserialized[EPOCH_KEY]).isEqualTo("1")
assertDoesNotThrow { Instant.parse(deserialized[MODIFIED_TIME_KEY]) }
assertThat(deserialized[MPV_KEY]).isEqualTo("5000")
}
}
@Test
fun `persistGroupParameters can persist over RPC topic`() {
vnodeEmf.transaction {
it.createQuery("DELETE FROM GroupParametersEntity").executeUpdate()
val entity = GroupParametersEntity(
1,
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(EPOCH_KEY, "1"),
KeyValuePair(MODIFIED_TIME_KEY, clock.instant().toString()),
KeyValuePair(MPV_KEY, "5000")
)
)
)!!
)
it.persist(entity)
}
val groupParameters = layeredPropertyMapFactory.create<TestGroupParametersImpl>(mapOf(
EPOCH_KEY to "2",
MPV_KEY to "5000",
MODIFIED_TIME_KEY to clock.instant().toString()
))
val persisted = membershipPersistenceClientWrapper.persistGroupParameters(viewOwningHoldingIdentity, groupParameters)
assertThat(persisted).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val persistedEntity = vnodeEmf.use {
it.find(
GroupParametersEntity::class.java,
2
)
}
assertThat(persistedEntity).isNotNull
with(persistedEntity.parameters) {
val deserialized = cordaAvroDeserializer.deserialize(this)!!.toMap()
assertThat(deserialized.size).isEqualTo(3)
assertThat(deserialized[EPOCH_KEY]).isEqualTo("2")
assertDoesNotThrow { Instant.parse(deserialized[MODIFIED_TIME_KEY]) }
assertThat(deserialized[MPV_KEY]).isEqualTo("5000")
}
}
@Test
fun `addNotaryToGroupParameters can persist new notary service over RPC topic`() {
vnodeEmf.transaction {
it.createQuery("DELETE FROM GroupParametersEntity").executeUpdate()
val entity = GroupParametersEntity(
50,
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(EPOCH_KEY, "50"),
KeyValuePair(MODIFIED_TIME_KEY, clock.instant().toString()),
KeyValuePair(MPV_KEY, "5000")
)
)
)!!
)
it.persist(entity)
}
val groupId = randomUUID().toString()
val memberx500Name = MemberX500Name.parse("O=Notary, C=GB, L=London")
val endpointUrl = "https://localhost:8080"
val notaryServiceName = "O=New Service, L=London, C=GB"
val notaryServicePlugin = "Notary Plugin"
val notaryKey = with(KeyPairGenerator.getInstance("RSA", BouncyCastleProvider())) {
generateKeyPair().public
}
val notaryKeyHash = notaryKey.calculateHash()
val memberContext = KeyValuePairList(
listOf(
KeyValuePair(String.format(URL_KEY, "0"), endpointUrl),
KeyValuePair(String.format(PROTOCOL_VERSION, "0"), "1"),
KeyValuePair(GROUP_ID, groupId),
KeyValuePair(PARTY_NAME, memberx500Name.toString()),
KeyValuePair(PLATFORM_VERSION, "11"),
KeyValuePair(SOFTWARE_VERSION, "5.0.0"),
KeyValuePair("corda.notary.service.name", notaryServiceName),
KeyValuePair("corda.notary.service.plugin", notaryServicePlugin),
KeyValuePair("corda.roles.0", "notary"),
KeyValuePair("corda.notary.keys.0.pem", keyEncodingService.encodeAsString(notaryKey)),
KeyValuePair("corda.notary.keys.0.signature.spec", "SHA512withECDSA"),
KeyValuePair("corda.notary.keys.0.hash", notaryKeyHash.value),
).sorted()
)
val mgmContext = KeyValuePairList(
listOf(
KeyValuePair(STATUS, MEMBER_STATUS_ACTIVE),
KeyValuePair(SERIAL, "1"),
).sorted()
)
val notary = memberInfoFactory.create(memberContext.toSortedMap(), mgmContext.toSortedMap())
val expectedGroupParameters = listOf(
KeyValuePair(EPOCH_KEY, "51"),
KeyValuePair(MPV_KEY, "5000"),
KeyValuePair("corda.notary.service.0.name", notaryServiceName),
KeyValuePair("corda.notary.service.0.plugin", notaryServicePlugin),
KeyValuePair("corda.notary.service.0.keys.0", keyEncodingService.encodeAsString(notaryKey)),
)
val persisted = membershipPersistenceClientWrapper.addNotaryToGroupParameters(viewOwningHoldingIdentity, notary)
assertThat(persisted).isInstanceOf(MembershipPersistenceResult.Success::class.java)
with((persisted as? MembershipPersistenceResult.Success<KeyValuePairList>)!!.payload.items) {
assertThat(size).isEqualTo(6)
assertThat(containsAll(expectedGroupParameters))
}
val persistedEntity = vnodeEmf.use {
it.find(
GroupParametersEntity::class.java,
51
)
}
assertThat(persistedEntity).isNotNull
with(persistedEntity.parameters) {
val deserialized = cordaAvroDeserializer.deserialize(this)!!
assertThat(deserialized.items.size).isEqualTo(6)
assertThat(deserialized.items.containsAll(expectedGroupParameters))
assertDoesNotThrow { Instant.parse(deserialized.toMap()[MODIFIED_TIME_KEY]) }
}
}
@Test
fun `addNotaryToGroupParameters can persist notary to existing notary service over RPC topic`() {
val groupId = randomUUID().toString()
val memberx500Name = MemberX500Name.parse("O=Notary, C=GB, L=London")
val endpointUrl = "http://localhost:8080"
val notaryServiceName = "O=New Service, L=London, C=GB"
val notaryServicePlugin = "Notary Plugin"
val notaryKey = with(KeyPairGenerator.getInstance("RSA", BouncyCastleProvider())) {
generateKeyPair().public
}
val notaryKeyAsString = keyEncodingService.encodeAsString(notaryKey)
val notaryKeyHash = notaryKey.calculateHash()
val memberContext = KeyValuePairList(
listOf(
KeyValuePair(String.format(URL_KEY, "0"), endpointUrl),
KeyValuePair(String.format(PROTOCOL_VERSION, "0"), "1"),
KeyValuePair(GROUP_ID, groupId),
KeyValuePair(PARTY_NAME, memberx500Name.toString()),
KeyValuePair(PLATFORM_VERSION, "11"),
KeyValuePair(SOFTWARE_VERSION, "5.0.0"),
KeyValuePair("corda.notary.service.name", notaryServiceName),
KeyValuePair("corda.notary.service.plugin", notaryServicePlugin),
KeyValuePair("corda.roles.0", "notary"),
KeyValuePair("corda.notary.keys.0.pem", notaryKeyAsString),
KeyValuePair("corda.notary.keys.0.signature.spec", "SHA512withECDSA"),
KeyValuePair("corda.notary.keys.0.hash", notaryKeyHash.value),
).sorted()
)
val mgmContext = KeyValuePairList(
listOf(
KeyValuePair(STATUS, MEMBER_STATUS_ACTIVE),
KeyValuePair(SERIAL, "1"),
).sorted()
)
val notary = memberInfoFactory.create(memberContext.toSortedMap(), mgmContext.toSortedMap())
vnodeEmf.transaction {
it.createQuery("DELETE FROM GroupParametersEntity").executeUpdate()
val entity = GroupParametersEntity(
100,
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(EPOCH_KEY, "100"),
KeyValuePair(MODIFIED_TIME_KEY, clock.instant().toString()),
KeyValuePair(MPV_KEY, "5000"),
KeyValuePair("corda.notary.service.0.name", notaryServiceName),
KeyValuePair("corda.notary.service.0.plugin", notaryServicePlugin)
)
)
)!!
)
it.persist(entity)
}
val expectedGroupParameters = listOf(
KeyValuePair(EPOCH_KEY, "101"),
KeyValuePair(MPV_KEY, "5000"),
KeyValuePair("corda.notary.service.0.name", notaryServiceName),
KeyValuePair("corda.notary.service.0.plugin", notaryServicePlugin),
KeyValuePair("corda.notary.service.0.keys.0", notaryKeyAsString),
)
val persisted = membershipPersistenceClientWrapper.addNotaryToGroupParameters(viewOwningHoldingIdentity, notary)
assertThat(persisted).isInstanceOf(MembershipPersistenceResult.Success::class.java)
with((persisted as? MembershipPersistenceResult.Success<KeyValuePairList>)!!.payload.items) {
assertThat(size).isEqualTo(6)
assertThat(containsAll(expectedGroupParameters))
}
val persistedEntity = vnodeEmf.use {
it.find(
GroupParametersEntity::class.java,
101
)
}
assertThat(persistedEntity).isNotNull
with(persistedEntity.parameters) {
val deserialized = cordaAvroDeserializer.deserialize(this)!!
assertThat(deserialized.items.size).isEqualTo(6)
assertThat(deserialized.items.containsAll(expectedGroupParameters))
assertDoesNotThrow { Instant.parse(deserialized.toMap()[MODIFIED_TIME_KEY]) }
}
}
@Test
fun `addNotaryToGroupParameters can persist notary with rotated keys over RPC topic`() {
val keyGenerator = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider())
val groupId = randomUUID().toString()
val memberx500Name = MemberX500Name.parse("O=Notary, C=GB, L=London")
val endpointUrl = "http://localhost:8080"
val notaryServiceName = "O=New Service, L=London, C=GB"
val notaryServicePlugin = "Notary Plugin"
val notaryKey = with(keyGenerator) {
generateKeyPair().public
}
val notaryKeyAsString = keyEncodingService.encodeAsString(notaryKey)
val notaryKeyHash = notaryKey.calculateHash()
val memberContext = KeyValuePairList(
listOf(
KeyValuePair(String.format(URL_KEY, "0"), endpointUrl),
KeyValuePair(String.format(PROTOCOL_VERSION, "0"), "1"),
KeyValuePair(GROUP_ID, groupId),
KeyValuePair(PARTY_NAME, memberx500Name.toString()),
KeyValuePair(PLATFORM_VERSION, "11"),
KeyValuePair(SOFTWARE_VERSION, "5.0.0"),
KeyValuePair("corda.notary.service.name", notaryServiceName),
KeyValuePair("corda.notary.service.plugin", notaryServicePlugin),
KeyValuePair("corda.roles.0", "notary"),
KeyValuePair("corda.notary.keys.0.pem", notaryKeyAsString),
KeyValuePair("corda.notary.keys.0.signature.spec", "SHA512withECDSA"),
KeyValuePair("corda.notary.keys.0.hash", notaryKeyHash.value),
).sorted()
)
val mgmContext = KeyValuePairList(
listOf(
KeyValuePair(STATUS, MEMBER_STATUS_ACTIVE),
KeyValuePair(SERIAL, "1"),
).sorted()
)
val notary = memberInfoFactory.create(memberContext.toSortedMap(), mgmContext.toSortedMap())
val oldNotaryKey = with(keyGenerator) {
keyEncodingService.encodeAsString(generateKeyPair().public)
}
vnodeEmf.transaction {
it.createQuery("DELETE FROM GroupParametersEntity").executeUpdate()
val entity = GroupParametersEntity(
150,
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(EPOCH_KEY, "150"),
KeyValuePair(MODIFIED_TIME_KEY, clock.instant().toString()),
KeyValuePair(MPV_KEY, "5000"),
KeyValuePair("corda.notary.service.0.name", notaryServiceName),
KeyValuePair("corda.notary.service.0.plugin", notaryServicePlugin),
KeyValuePair("corda.notary.service.0.keys.0", oldNotaryKey)
)
)
)!!
)
it.persist(entity)
}
val expectedGroupParameters = listOf(
KeyValuePair(EPOCH_KEY, "151"),
KeyValuePair(MPV_KEY, "5000"),
KeyValuePair("corda.notary.service.0.name", notaryServiceName),
KeyValuePair("corda.notary.service.0.plugin", notaryServicePlugin),
KeyValuePair("corda.notary.service.0.keys.0", oldNotaryKey),
KeyValuePair("corda.notary.service.0.keys.1", notaryKeyAsString),
)
val persisted = membershipPersistenceClientWrapper.addNotaryToGroupParameters(viewOwningHoldingIdentity, notary)
assertThat(persisted).isInstanceOf(MembershipPersistenceResult.Success::class.java)
with((persisted as? MembershipPersistenceResult.Success<KeyValuePairList>)!!.payload.items) {
assertThat(size).isEqualTo(7)
assertThat(containsAll(expectedGroupParameters))
}
val persistedEntity = vnodeEmf.use {
it.find(
GroupParametersEntity::class.java,
151
)
}
assertThat(persistedEntity).isNotNull
with(persistedEntity.parameters) {
val deserialized = cordaAvroDeserializer.deserialize(this)!!
assertThat(deserialized.items.size).isEqualTo(7)
assertThat(deserialized.items.containsAll(expectedGroupParameters))
assertDoesNotThrow { Instant.parse(deserialized.toMap()[MODIFIED_TIME_KEY]) }
}
}
@Test
fun `member infos can persist over RPC topic`() {
val groupId = randomUUID().toString()
val memberx500Name = MemberX500Name.parse("O=Alice, C=GB, L=London")
val endpointUrl = "http://localhost:8080"
val memberContext = KeyValuePairList(
listOf(
KeyValuePair(String.format(URL_KEY, "0"), endpointUrl),
KeyValuePair(String.format(PROTOCOL_VERSION, "0"), "1"),
KeyValuePair(GROUP_ID, groupId),
KeyValuePair(PARTY_NAME, memberx500Name.toString()),
KeyValuePair(PLATFORM_VERSION, "5000"),
KeyValuePair(SOFTWARE_VERSION, "5.0.0"),
).sorted()
)
val mgmContext = KeyValuePairList(
listOf(
KeyValuePair(STATUS, MEMBER_STATUS_ACTIVE),
KeyValuePair(SERIAL, "1"),
).sorted()
)
val result = membershipPersistenceClientWrapper.persistMemberInfo(
viewOwningHoldingIdentity,
listOf(
memberInfoFactory.create(
memberContext.toSortedMap(),
mgmContext.toSortedMap()
)
)
)
assertThat(result).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val persistedEntity = vnodeEmf.use {
it.find(
MemberInfoEntity::class.java,
MemberInfoEntityPrimaryKey(
groupId, memberx500Name.toString()
)
)
}
assertThat(persistedEntity).isNotNull
assertThat(persistedEntity.groupId).isEqualTo(groupId)
assertThat(persistedEntity.memberX500Name).isEqualTo(memberx500Name.toString())
assertThat(persistedEntity.serialNumber).isEqualTo(1)
assertThat(persistedEntity.status).isEqualTo(MEMBER_STATUS_ACTIVE)
val persistedMgmContext = persistedEntity.mgmContext.deserializeContextAsMap()
assertThat(persistedMgmContext)
.containsEntry(STATUS, MEMBER_STATUS_ACTIVE)
.containsEntry(SERIAL, "1")
val persistedMemberContext = persistedEntity.memberContext.deserializeContextAsMap()
assertThat(persistedMemberContext)
.containsEntry(String.format(URL_KEY, "0"), endpointUrl)
.containsEntry(String.format(PROTOCOL_VERSION, "0"), "1")
.containsEntry(GROUP_ID, groupId)
.containsEntry(PARTY_NAME, memberx500Name.toString())
.containsEntry(PLATFORM_VERSION, "5000")
.containsEntry(SOFTWARE_VERSION, "5.0.0")
}
@Test
fun `setMemberAndRegistrationRequestAsApproved update the member and registration request`() {
// 1. Persist a member
val memberPersistentResult = persistMember(registeringX500Name)
assertThat(memberPersistentResult).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val memberEntity = vnodeEmf.use {
it.find(
MemberInfoEntity::class.java,
MemberInfoEntityPrimaryKey(
groupId, registeringX500Name.toString()
)
)
}
assertThat(memberEntity.status).isEqualTo(MEMBER_STATUS_PENDING)
// 2. Persist a request
val registrationId = randomUUID().toString()
val requestPersistentResult = persistRequest(registeringHoldingIdentity, registrationId)
assertThat(requestPersistentResult).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val requestEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(requestEntity.status).isEqualTo(RegistrationStatus.SENT_TO_MGM.toString())
val approveResult = membershipPersistenceClientWrapper.setMemberAndRegistrationRequestAsApproved(
viewOwningHoldingIdentity,
registeringHoldingIdentity,
registrationId,
).getOrThrow()
assertThat(approveResult.status).isEqualTo(MEMBER_STATUS_ACTIVE)
assertThat(approveResult.groupId).isEqualTo(groupId)
assertThat(approveResult.name).isEqualTo(registeringHoldingIdentity.x500Name)
val newMemberEntity = vnodeEmf.use {
it.find(
MemberInfoEntity::class.java,
MemberInfoEntityPrimaryKey(
groupId, registeringX500Name.toString()
)
)
}
assertThat(newMemberEntity.status).isEqualTo(MEMBER_STATUS_ACTIVE)
val newRequestEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(newRequestEntity.status).isEqualTo(RegistrationStatus.APPROVED.toString())
}
@Test
fun `setMemberAndRegistrationRequestAsDeclined updates the member and registration request`() {
// 1. Persist a member
val registeringX500Name = MemberX500Name.parse("O=Charlie, C=GB, L=London")
val registeringHoldingIdentity = HoldingIdentity(registeringX500Name, groupId)
val memberPersistentResult = persistMember(registeringX500Name)
assertThat(memberPersistentResult).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val memberEntity = vnodeEmf.use {
it.find(
MemberInfoEntity::class.java,
MemberInfoEntityPrimaryKey(
groupId, registeringX500Name.toString()
)
)
}
assertThat(memberEntity.status).isEqualTo(MEMBER_STATUS_PENDING)
// 2. Persist a request
val registrationId = randomUUID().toString()
val requestPersistentResult = persistRequest(registeringHoldingIdentity, registrationId)
assertThat(requestPersistentResult).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val requestEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(requestEntity.status).isEqualTo(RegistrationStatus.SENT_TO_MGM.toString())
membershipPersistenceClientWrapper.setMemberAndRegistrationRequestAsDeclined(
viewOwningHoldingIdentity,
registeringHoldingIdentity,
registrationId,
).getOrThrow()
val newMemberEntity = vnodeEmf.use {
it.find(
MemberInfoEntity::class.java,
MemberInfoEntityPrimaryKey(
groupId, registeringX500Name.toString()
)
)
}
assertThat(newMemberEntity.status).isEqualTo(MEMBER_STATUS_DECLINED)
val newRequestEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(newRequestEntity.status).isEqualTo(RegistrationStatus.DECLINED.toString())
}
@Test
fun `queryMembersSignatures returns the member signatures`() {
membershipQueryClient.start()
eventually {
assertThat(membershipPersistenceClient.isRunning).isTrue
}
val signatures = (1..5).associate { index ->
val registrationId = randomUUID().toString()
val holdingId = createTestHoldingIdentity("O=Bob-$index, C=GB, L=London", groupId)
val publicKey = ByteBuffer.wrap("pk-$index".toByteArray())
val signature = ByteBuffer.wrap("signature-$index".toByteArray())
val context = KeyValuePairList(
listOf(
KeyValuePair(MEMBER_CONTEXT_KEY, MEMBER_CONTEXT_VALUE)
)
)
val signatureContext = KeyValuePairList(
listOf(
KeyValuePair("key", "value")
)
)
membershipPersistenceClientWrapper.persistRegistrationRequest(
viewOwningHoldingIdentity,
RegistrationRequest(
RegistrationStatus.SENT_TO_MGM,
registrationId,
holdingId,
ByteBuffer.wrap(
cordaAvroSerializer.serialize(
context
)
),
CryptoSignatureWithKey(
publicKey,
signature,
signatureContext,
)
)
).getOrThrow()
val cryptoSignatureWithKey = CryptoSignatureWithKey(
publicKey, signature, signatureContext
)
holdingId to cryptoSignatureWithKey
}
val results = membershipQueryClient.queryMembersSignatures(
viewOwningHoldingIdentity,
signatures.keys
).getOrThrow()
assertThat(results).containsAllEntriesOf(signatures)
}
@Test
fun `setRegistrationRequestStatus updates the registration request status`() {
val registrationId = randomUUID().toString()
val persistRegRequestResult = membershipPersistenceClientWrapper.persistRegistrationRequest(
viewOwningHoldingIdentity,
RegistrationRequest(
RegistrationStatus.SENT_TO_MGM,
registrationId,
registeringHoldingIdentity,
ByteBuffer.wrap(
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(MEMBER_CONTEXT_KEY, MEMBER_CONTEXT_VALUE)
)
)
)
),
CryptoSignatureWithKey(
ByteBuffer.wrap(byteArrayOf()),
ByteBuffer.wrap(byteArrayOf()),
KeyValuePairList(emptyList()),
),
)
)
assertThat(persistRegRequestResult).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val persistedEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(persistedEntity).isNotNull
assertThat(persistedEntity.registrationId).isEqualTo(registrationId)
assertThat(persistedEntity.holdingIdentityShortHash).isEqualTo(registeringHoldingIdentity.shortHash.value)
assertThat(persistedEntity.status).isEqualTo(RegistrationStatus.SENT_TO_MGM.name)
val updateRegRequestStatusResult = membershipPersistenceClientWrapper.setRegistrationRequestStatus(
viewOwningHoldingIdentity,
registrationId,
RegistrationStatus.PENDING_AUTO_APPROVAL
)
assertThat(updateRegRequestStatusResult).isInstanceOf(MembershipPersistenceResult.Success::class.java)
val updatedEntity = vnodeEmf.use {
it.find(RegistrationRequestEntity::class.java, registrationId)
}
assertThat(updatedEntity).isNotNull
assertThat(updatedEntity.registrationId).isEqualTo(registrationId)
assertThat(updatedEntity.holdingIdentityShortHash).isEqualTo(registeringHoldingIdentity.shortHash.value)
assertThat(updatedEntity.status).isEqualTo(RegistrationStatus.PENDING_AUTO_APPROVAL.name)
}
@Test
fun `addApprovalRule persists the approval rule and returns the rule ID`() {
vnodeEmf.transaction {
it.createQuery("DELETE FROM ApprovalRulesEntity").executeUpdate()
}
val ruleDetails = membershipPersistenceClientWrapper.addApprovalRule(
viewOwningHoldingIdentity,
ApprovalRuleParams(RULE_REGEX, ApprovalRuleType.STANDARD, RULE_LABEL)
).getOrThrow()
val approvalRuleEntity = vnodeEmf.use {
it.find(
ApprovalRulesEntity::class.java,
ApprovalRulesEntityPrimaryKey(
ruleDetails.ruleId,
ApprovalRuleType.STANDARD.name
)
)
}
with(approvalRuleEntity) {
assertThat(ruleRegex).isEqualTo(RULE_REGEX)
assertThat(ruleType).isEqualTo(ApprovalRuleType.STANDARD.name)
assertThat(ruleLabel).isEqualTo(RULE_LABEL)
}
}
@Test
fun `deleteApprovalRule deletes the approval rule from the db`() {
vnodeEmf.transaction {
it.createQuery("DELETE FROM ApprovalRulesEntity").executeUpdate()
}
val testRule = ApprovalRulesEntity(RULE_ID, ApprovalRuleType.STANDARD.name, RULE_REGEX, RULE_LABEL)
vnodeEmf.transaction {
it.persist(testRule)
}
membershipPersistenceClientWrapper.deleteApprovalRule(
viewOwningHoldingIdentity, RULE_ID, ApprovalRuleType.STANDARD
).getOrThrow()
vnodeEmf.use {
assertThat(
it.find(
ApprovalRulesEntity::class.java,
ApprovalRulesEntityPrimaryKey(
RULE_ID,
ApprovalRuleType.STANDARD.name
)
)
).isNull()
}
}
@Test
fun `getApprovalRules retrieves all approval rules`() {
vnodeEmf.transaction {
it.createQuery("DELETE FROM ApprovalRulesEntity").executeUpdate()
}
membershipQueryClient.start()
eventually {
assertThat(membershipPersistenceClient.isRunning).isTrue
}
val rule1 = ApprovalRuleDetails(RULE_ID, RULE_REGEX, RULE_LABEL)
val rule2 = ApprovalRuleDetails("rule-id-2", "rule-regex-2", "rule-label-2")
val entities = listOf(
ApprovalRulesEntity(rule1.ruleId, ApprovalRuleType.STANDARD.name, rule1.ruleRegex, rule1.ruleLabel),
ApprovalRulesEntity(rule2.ruleId, ApprovalRuleType.STANDARD.name, rule2.ruleRegex, rule2.ruleLabel)
)
vnodeEmf.transaction { em ->
entities.forEach { em.persist(it) }
}
val result = membershipQueryClient.getApprovalRules(
viewOwningHoldingIdentity,
ApprovalRuleType.STANDARD
).getOrThrow()
assertThat(result.size).isEqualTo(2)
assertThat(result).containsAll(listOf(rule1, rule2))
}
private fun ByteArray.deserializeContextAsMap(): Map<String, String> =
cordaAvroDeserializer.deserialize(this)
?.items
?.associate { it.key to it.value } ?: fail("Failed to deserialize context.")
private fun persistMember(memberName: MemberX500Name): MembershipPersistenceResult<Unit> {
val endpointUrl = "http://localhost:8080"
val memberContext = KeyValuePairList(
listOf(
KeyValuePair(String.format(URL_KEY, "0"), endpointUrl),
KeyValuePair(String.format(PROTOCOL_VERSION, "0"), "1"),
KeyValuePair(GROUP_ID, groupId),
KeyValuePair(PARTY_NAME, memberName.toString()),
KeyValuePair(PLATFORM_VERSION, "5000"),
KeyValuePair(SOFTWARE_VERSION, "5.0.0"),
).sorted()
)
val mgmContext = KeyValuePairList(
listOf(
KeyValuePair(STATUS, MEMBER_STATUS_PENDING),
KeyValuePair(SERIAL, "1"),
).sorted()
)
return membershipPersistenceClientWrapper.persistMemberInfo(
viewOwningHoldingIdentity,
listOf(
memberInfoFactory.create(
memberContext.toSortedMap(),
mgmContext.toSortedMap()
)
)
)
}
private fun persistRequest(member: HoldingIdentity, registrationId: String): MembershipPersistenceResult<Unit> {
return membershipPersistenceClientWrapper.persistRegistrationRequest(
viewOwningHoldingIdentity,
RegistrationRequest(
RegistrationStatus.SENT_TO_MGM,
registrationId,
member,
ByteBuffer.wrap(
cordaAvroSerializer.serialize(
KeyValuePairList(
listOf(
KeyValuePair(MEMBER_CONTEXT_KEY, MEMBER_CONTEXT_VALUE)
)
)
)
),
CryptoSignatureWithKey(
ByteBuffer.wrap(byteArrayOf()),
ByteBuffer.wrap(byteArrayOf()),
KeyValuePairList(emptyList()),
),
)
)
}
private class TestGroupParametersImpl(
private val map: LayeredPropertyMap
) : LayeredPropertyMap by map, GroupParameters {
override val epoch: Int
get() = 5
override val minimumPlatformVersion: Int
get() = 5000
override val modifiedTime: Instant
get() = clock.instant()
override val notaries: List<NotaryInfo>
get() = emptyList()
}
}
| 82 | Kotlin | 7 | 24 | 17f5d2e5585a8ac56e559d1c099eaee414e6ec5a | 55,802 | corda-runtime-os | Apache License 2.0 |
line-awesome/src/commonMain/kotlin/compose/icons/lineawesomeicons/Bitcoin.kt | DevSrSouza | 311,134,756 | false | {"Kotlin": 36756847} | package compose.icons.lineawesomeicons
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.PathFillType.NonZero
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.StrokeCap.Butt
import androidx.compose.ui.graphics.StrokeJoin.Miter
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.graphics.vector.ImageVector.Builder
import androidx.compose.ui.graphics.vector.path
import androidx.compose.ui.unit.dp
import compose.icons.LineAwesomeIcons
public val LineAwesomeIcons.Bitcoin: ImageVector
get() {
if (_bitcoin != null) {
return _bitcoin!!
}
_bitcoin = Builder(name = "Bitcoin", defaultWidth = 32.0.dp, defaultHeight = 32.0.dp,
viewportWidth = 32.0f, viewportHeight = 32.0f).apply {
path(fill = SolidColor(Color(0xFF000000)), stroke = null, strokeLineWidth = 0.0f,
strokeLineCap = Butt, strokeLineJoin = Miter, strokeLineMiter = 4.0f,
pathFillType = NonZero) {
moveTo(12.0f, 3.0f)
lineTo(12.0f, 6.0f)
lineTo(8.0f, 6.0f)
lineTo(8.0f, 26.0f)
lineTo(12.0f, 26.0f)
lineTo(12.0f, 29.0f)
lineTo(14.0f, 29.0f)
lineTo(14.0f, 26.0f)
lineTo(16.0f, 26.0f)
lineTo(16.0f, 29.0f)
lineTo(18.0f, 29.0f)
lineTo(18.0f, 26.0f)
lineTo(19.5f, 26.0f)
curveTo(22.5273f, 26.0f, 25.0f, 23.5273f, 25.0f, 20.5f)
curveTo(25.0f, 18.418f, 23.8398f, 16.5898f, 22.125f, 15.6563f)
curveTo(23.2813f, 14.6445f, 24.0f, 13.1484f, 24.0f, 11.5f)
curveTo(24.0f, 8.4727f, 21.5273f, 6.0f, 18.5f, 6.0f)
lineTo(18.0f, 6.0f)
lineTo(18.0f, 3.0f)
lineTo(16.0f, 3.0f)
lineTo(16.0f, 6.0f)
lineTo(14.0f, 6.0f)
lineTo(14.0f, 3.0f)
close()
moveTo(10.0f, 8.0f)
lineTo(18.5f, 8.0f)
curveTo(20.4453f, 8.0f, 22.0f, 9.5547f, 22.0f, 11.5f)
curveTo(22.0f, 13.4453f, 20.4453f, 15.0f, 18.5f, 15.0f)
lineTo(10.0f, 15.0f)
close()
moveTo(10.0f, 17.0f)
lineTo(19.5f, 17.0f)
curveTo(21.4453f, 17.0f, 23.0f, 18.5547f, 23.0f, 20.5f)
curveTo(23.0f, 22.4453f, 21.4453f, 24.0f, 19.5f, 24.0f)
lineTo(10.0f, 24.0f)
close()
}
}
.build()
return _bitcoin!!
}
private var _bitcoin: ImageVector? = null
| 15 | Kotlin | 20 | 460 | 651badc4ace0137c5541f859f61ffa91e5242b83 | 2,739 | compose-icons | MIT License |
domain/src/test/java/com/foobarust/domain/usecases/auth/RequestAuthEmailUseCaseTest.kt | foobar-UST | 285,792,732 | false | null | package com.foobarust.domain.usecases.auth
import com.foobarust.domain.states.Resource
import com.foobarust.testshared.di.DependencyContainer
import com.foobarust.testshared.repositories.FakeAuthRepositoryImpl
import com.foobarust.testshared.utils.TestCoroutineRule
import com.foobarust.testshared.utils.coroutineScope
import com.foobarust.testshared.utils.runBlockingTest
import kotlinx.coroutines.flow.toList
import org.junit.Before
import org.junit.Rule
import org.junit.Test
/**
* Created by kevin on 4/21/21
*/
class RequestAuthEmailUseCaseTest {
private lateinit var requestAuthEmailUseCase: RequestAuthEmailUseCase
private lateinit var fakeAuthRepositoryImpl: FakeAuthRepositoryImpl
private lateinit var dependencyContainer: DependencyContainer
@get:Rule
var coroutineRule = TestCoroutineRule()
@Before
fun init() {
dependencyContainer = DependencyContainer()
fakeAuthRepositoryImpl = FakeAuthRepositoryImpl(
idToken = dependencyContainer.fakeIdToken,
defaultAuthProfile = dependencyContainer.fakeAuthProfile,
isSignedIn = false,
coroutineScope = coroutineRule.coroutineScope()
)
requestAuthEmailUseCase = RequestAuthEmailUseCase(
authRepository = fakeAuthRepositoryImpl,
coroutineDispatcher = coroutineRule.testDispatcher
)
}
@Test
fun `test request success`() = coroutineRule.runBlockingTest {
fakeAuthRepositoryImpl.setNetworkError(false)
val results = requestAuthEmailUseCase(FAKE_AUTH_EMAIL).toList()
assert(results.last() is Resource.Success)
}
@Test
fun `test request failure`() = coroutineRule.runBlockingTest {
fakeAuthRepositoryImpl.setNetworkError(true)
val results = requestAuthEmailUseCase(FAKE_AUTH_EMAIL).toList()
assert(results.last() is Resource.Error)
}
companion object {
private const val FAKE_AUTH_EMAIL = "<EMAIL>"
}
} | 0 | Kotlin | 2 | 2 | b4358ef0323a0b7a95483223496164e616a01da5 | 1,993 | foobar-android | MIT License |
TextScrollingApp/app/src/main/java/com/example/textscrollingapp/MainActivity.kt | sad786 | 196,528,384 | false | null | package com.example.textscrollingapp
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.content.Intent
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val btn = findViewById<Button>(R.id.comment)
btn.setOnClickListener{
val intent = Intent("com.example.dell.helloworld.MainActivity")
intent.addCategory("LAUNCHER")
intent.setClassName("com.example.dell.helloWorld","MainActivity")
startActivity(intent)
}
}
}
| 0 | Kotlin | 0 | 0 | b87caf8ac3668f96629677ed5342b89ac151629a | 698 | AndroidProjects | MIT License |
drivers/jvm/core/src/main/kotlin/io/pact/plugins/jvm/core/MockServer.kt | pact-foundation | 388,319,964 | false | {"Rust": 276682, "Kotlin": 157386, "Groovy": 41603, "Shell": 13990} | package io.pact.plugins.jvm.core
/**
* Configuration settings to use to start a mock server
*/
data class MockServerConfig(
/**
* Host interface to use for the mock server. Defaults to the loopback adapter (127.0.0.1).
*/
val hostInterface: String = "",
/**
* Port number to bind to. Defaults to 0, which causes a random free port to be chosen.
*/
val port: Int = 0,
/**
* If TLS should be used. If enabled, a mock server with a self-signed cert will be started (if the mock server
* supports TLS).
*/
val tls: Boolean = false
)
/**
* Details on a running mock server
*/
data class MockServerDetails(
/**
* Unique key for the mock server
*/
val key: String,
/**
* Base URL to the running mock server
*/
val baseUrl: String,
/**
* Port the mock server is running on
*/
val port: Int,
/**
* Plugin the mock server belongs to
*/
val plugin: PactPlugin
)
/**
* Results from the mock server. These will be returned when the mock server is shutdown
*/
data class MockServerResults(
/** service + method that was requested */
val path: String,
/** If an error occurred trying to handle the request */
val error: String?,
/** Any mismatches that occurred */
val mismatches: List<MockServerMismatch>
)
/**
* Mismatch detected by the mock server
*/
data class MockServerMismatch(
/** Expected data bytes */
val expected: Any?,
/** Actual data bytes */
val actual: Any?,
/** Description of the mismatch */
val mismatch: String,
/** Path to the item that was matched. This is the value as per the documented Pact matching rule expressions. */
val path: String,
/** Optional diff of the contents */
val diff: String?,
/** Type of object that the mismatch applies to: body, headers, metadata, etc. */
val mismatchType: String? = null
)
| 18 | Rust | 11 | 19 | 0d71168505b9afe53f565da8cd7453313336f275 | 1,848 | pact-plugins | MIT License |
core/data/src/main/java/com/wap/wapp/core/data/repository/management/ManagementRepository.kt | pknu-wap | 689,890,586 | false | {"Kotlin": 326232, "Shell": 233} | package com.wap.wapp.core.data.repository.management
interface ManagementRepository {
suspend fun isManager(userId: String): Result<Boolean>
suspend fun postManager(userId: String): Result<Unit>
suspend fun getManagementCode(code: String): Result<Boolean>
suspend fun deleteManager(userId: String): Result<Unit>
}
| 7 | Kotlin | 0 | 8 | eb7037bb699ae994bbb280e774a1c18c486a1953 | 334 | WAPP | MIT License |
android/shared/src/commonMain/kotlin/io/rebble/cobble/shared/middleware/AppLogController.kt | pebble-dev | 295,813,856 | false | {"Kotlin": 770908, "Dart": 604224, "Java": 261839, "Objective-C": 165254, "Swift": 110627, "JavaScript": 23686, "Ruby": 1469, "HTML": 305, "C": 211, "Shell": 29} | package io.rebble.cobble.shared.middleware
import io.rebble.cobble.shared.Logging
import io.rebble.cobble.shared.domain.common.PebbleDevice
import io.rebble.cobble.shared.domain.state.ConnectionState
import io.rebble.cobble.shared.domain.state.ConnectionStateManager
import io.rebble.libpebblecommon.packets.AppLogShippingControlMessage
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.withContext
class AppLogController(
private val pebbleDevice: PebbleDevice,
) {
@OptIn(ExperimentalCoroutinesApi::class)
val logs = ConnectionStateManager.connectionState.flatMapLatest {
if (it is ConnectionState.Connected) {
flow {
toggleAppLogOnWatch(true)
emitAll(pebbleDevice.appLogsService.receivedMessages.receiveAsFlow())
}
} else {
emptyFlow()
}
}.onCompletion {
toggleAppLogOnWatch(false)
}.shareIn(GlobalScope, SharingStarted.WhileSubscribed(1000, 1000))
private suspend fun toggleAppLogOnWatch(enable: Boolean) {
try {
withContext(NonCancellable) {
pebbleDevice.appLogsService.send(AppLogShippingControlMessage(enable))
}
} catch (e: Exception) {
Logging.e("AppLog transmit error", e)
}
}
} | 57 | Kotlin | 24 | 147 | 111c30b0a6e2e6682b35b6e86dd2982ea27ab89f | 1,440 | mobile-app | Apache License 2.0 |
kb-tcl/kotlin-lsp/ktor-lsp/src/main/kotlin/jsonrpc/language/LanguageServerCapabilities.kt | richnou | 809,891,863 | false | {"Kotlin": 46709, "Tcl": 31650, "Shell": 3190, "Scala": 1061, "SystemVerilog": 950, "Ruby": 730, "Python": 344, "PowerShell": 206, "Makefile": 60} | package jsonrpc.language
import kotlinx.serialization.Serializable
@Serializable
data class CompletionOptions(
val resolveProvider : Boolean = false,
val triggerCharacters : Array<String>? =null,
val allCommitCharacters : Array<String>? =null,
val completionItem : CompletionOptionsCompletionItem = CompletionOptionsCompletionItem()
)
@Serializable
data class CompletionOptionsCompletionItem(
val labelDetailsSupport : Boolean = true,
)
| 0 | Kotlin | 0 | 0 | 42c7e85a1a085c688b55bed7c2dde35aa2d81ed2 | 480 | kissb | Apache License 2.0 |
src/backend/paas/common/common-client/src/main/kotlin/com/heapoverflow/common/client/consul/ConsulConstants.kt | panfairy | 577,309,391 | false | null | package com.heapoverflow.common.client.consul
object ConsulConstants {
const val PROJECT_TAG_REDIS_KEY = "project:setting:tag:v2"
const val HEAD_CONSUL_TAG = "X-HEAD-CONSUL-TAG"
}
| 0 | Kotlin | 0 | 0 | f7147a022a9e427e054926829905ec9c10469325 | 190 | ho-base | MIT License |
buildSrc/src/main/java/Retrofit.kt | oscarB1nar10 | 535,842,203 | false | {"Kotlin": 102735} | object Retrofit {
private const val retrofitVersion = "2.9.0"
const val retrofit = "com.squareup.retrofit2:retrofit:2.9.0"
const val retrofitConverter = "com.squareup.retrofit2:converter-gson:2.9.0"
const val retrofitScalarConverter = "com.squareup.retrofit2:converter-scalars:2.9.0"
} | 0 | Kotlin | 0 | 0 | 7c2b0c5ddd4b009e10e8540dc6792cd7438f7939 | 302 | Modern-Android | Apache License 2.0 |
app/src/main/kotlin/com/aquamorph/frcmanager/models/MatchScore2020.kt | AquaMorph | 43,819,985 | false | null | package com.aquamorph.frcmanager.models
import com.google.gson.annotations.Expose
import com.google.gson.annotations.SerializedName
/**
* Stores match data for 2020 game.
*
* @author <NAME>
* @version 1/31/2020
*/
data class MatchScore2020(
@Expose
@SerializedName("score_breakdown")
var scoreBreakdown: ScoreBreakDown?
) {
data class ScoreBreakDown(
@Expose
@SerializedName("comp_level")
var compLevel: String,
@Expose
@SerializedName("match_number")
var match_number: Int,
@Expose
@SerializedName("blue")
var blue: BreakDown2020,
@Expose
@SerializedName("red")
var red: BreakDown2020
)
data class BreakDown2020(
@Expose
@SerializedName("initLineRobot1")
var initLineRobot1: String,
@Expose
@SerializedName("endgameRobot1")
var endgameRobot1: String,
@Expose
@SerializedName("initLineRobot2")
var initLineRobot2: String,
@Expose
@SerializedName("endgameRobot2")
var endgameRobot2: String,
@Expose
@SerializedName("initLineRobot3")
var initLineRobot3: String,
@Expose
@SerializedName("endgameRobot3")
var endgameRobot3: String,
@Expose
@SerializedName("autoCellsBottom")
var autoCellsBottom: Int,
@Expose
@SerializedName("autoCellsOuter")
var autoCellsOuter: Int,
@Expose
@SerializedName("autoCellsInner")
var autoCellsInner: Int,
@Expose
@SerializedName("teleopCellsBottom")
var teleopCellsBottom: Int,
@Expose
@SerializedName("teleopCellsOuter")
var teleopCellsOuter: Int,
@Expose
@SerializedName("teleopCellsInner")
var teleopCellsInner: Int,
@Expose
@SerializedName("stage1Activated")
var stage1Activated: Boolean,
@Expose
@SerializedName("stage2Activated")
var stage2Activated: Boolean,
@Expose
@SerializedName("stage3Activated")
var stage3Activated: Boolean,
@Expose
@SerializedName("stage3TargetColor")
var stage3TargetColor: String,
@Expose
@SerializedName("endgameRungIsLevel")
var endgameRungIsLevel: String,
@Expose
@SerializedName("autoInitLinePoints")
var autoInitLinePoints: Int,
@Expose
@SerializedName("autoCellPoints")
var autoCellPoints: Int,
@Expose
@SerializedName("autoPoints")
var autoPoints: Int,
@Expose
@SerializedName("teleopCellPoints")
var teleopCellPoints: Int,
@Expose
@SerializedName("controlPanelPoints")
var controlPanelPoints: Int,
@Expose
@SerializedName("endgamePoints")
var endgamePoints: Int,
@Expose
@SerializedName("teleopPoints")
var teleopPoints: Int,
@Expose
@SerializedName("shieldOperationalRankingPoint")
var shieldOperationalRankingPoint: Boolean,
@Expose
@SerializedName("shieldEnergizedRankingPoint")
var shieldEnergizedRankingPoint: Boolean,
@Expose
@SerializedName("foulCount")
var foulCount: Int,
@Expose
@SerializedName("techFoulCount")
var techFoulCount: Int,
@Expose
@SerializedName("adjustPoints")
var adjustPoints: Int,
@Expose
@SerializedName("foulPoints")
var foulPoints: Int,
@Expose
@SerializedName("rp")
var rp: Int,
@Expose
@SerializedName("totalPoints")
var totalPoints: Int
)
}
| 12 | Kotlin | 0 | 0 | caa6b9a85259e7e965b1a01303621dab3d9ef71a | 3,743 | FRC-Manager | Apache License 2.0 |
src/commonMain/kotlin/containers/enemy/SpriteEnemy.kt | jmsmith84 | 477,833,807 | false | {"Kotlin": 62412, "Shell": 1210} | package containers.enemy
import com.soywiz.korge.view.Sprite
import com.soywiz.korge.view.position
import com.soywiz.korma.geom.IPoint
import containers.SpriteEntity
import program.*
@Suppress("MemberVisibilityCanBePrivate")
abstract class SpriteEnemy(
sprite: Sprite,
assets: AssetManager,
soundManager: SoundManager,
levelManager: LevelManager,
position: IPoint
) : SpriteEntity(sprite, assets, soundManager, levelManager), Enemy {
protected open val value = 100u
override fun kill() {
this.removeFromParent()
GameState.score += value
}
init {
position(position)
Log().debug { "Enemy created @ $position" }
}
}
| 0 | Kotlin | 0 | 0 | eaf699313ed94bd9817fea5cb6089a196a90caa2 | 689 | ld50-slime-pit | MIT License |
src/main/java/cy/ac/ucy/cs/anyplace/lib/android/ui/dialogs/ConfirmActionDialog.kt | dmsl | 300,647,134 | false | {"Kotlin": 744946, "Java": 15482} | package cy.ac.ucy.cs.anyplace.lib.android.ui.dialogs
import android.app.AlertDialog
import android.app.Dialog
import android.graphics.Color
import android.graphics.drawable.ColorDrawable
import android.os.Bundle
import android.view.LayoutInflater
import androidx.appcompat.content.res.AppCompatResources
import androidx.fragment.app.DialogFragment
import androidx.fragment.app.FragmentManager
import cy.ac.ucy.cs.anyplace.lib.R
import cy.ac.ucy.cs.anyplace.lib.android.data.anyplace.wrappers.LevelWrapper
import cy.ac.ucy.cs.anyplace.lib.android.data.anyplace.wrappers.LevelsWrapper
import cy.ac.ucy.cs.anyplace.lib.android.data.anyplace.wrappers.SpaceWrapper
import cy.ac.ucy.cs.anyplace.lib.android.extensions.TAG
import cy.ac.ucy.cs.anyplace.lib.databinding.DialogConfirmActionBinding
import java.lang.IllegalStateException
/**
* This components can be reused / specialized, instead of writing a Dialog each time
* Handy class that shows a dialog and accepts a [callback] to perform any necessary actions
* See it's usages for examples.
*
* The [callback] can be passed in as a lambda.
*/
open class ConfirmActionDialog(
val title: String,
val callback: () -> Unit,
val subtitle: String?,
val isImportant: Boolean,
val cancellable: Boolean) :
DialogFragment() {
companion object {
/**
* Creating the dialog.
* It gets a [SpaceWrapper], [LevelsWrapper], and a [LevelWrapper] and:
* - if each object is not null:
* - it is serialized (into a [String]) and put into the bundle
* - Once the dialog is created they are deserialized to provide additional clear cache options
*
* - TODO pass method over here
*/
fun SHOW(fragmentManager: FragmentManager,
title: String,
/** optional subtitle */
subtitle: String?=null,
/** cancel the dialog when clicking outside of it */
cancellable: Boolean = true,
/** show red colors if important */
isImportant: Boolean = false,
/** method to run when confirmed */
callback: () -> Unit) {
val dialog = ConfirmActionDialog(title, callback, subtitle, isImportant, cancellable)
val args = Bundle()
dialog.arguments = args
dialog.show(fragmentManager, "")
}
}
var _binding : DialogConfirmActionBinding?= null
private val binding get() = _binding!!
override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
return activity?.let {
_binding = DialogConfirmActionBinding.inflate(LayoutInflater.from(context))
val builder= AlertDialog.Builder(it)
isCancelable = cancellable
builder.setView(binding.root)
val dialog = builder.create()
dialog.window!!.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
// android:background="@drawable/button_delete"
val drawableId = if (isImportant) {
R.drawable.button_delete
} else {
R.drawable.button_confirm
}
binding.btnConfirm.background= AppCompatResources.getDrawable(requireContext(), drawableId)
binding.tvTitle.text = title
subtitle?.let { binding.tvSubtitle.text = subtitle }
setupConfirmButton()
return dialog
}?: throw IllegalStateException("$TAG Activity is null.")
}
private fun setupConfirmButton() {
val btn = binding.btnConfirm
btn.setOnClickListener {
callback()
dismiss()
}
}
}
| 0 | Kotlin | 1 | 3 | 653becd0961171ad33fa25fac2260927ce5f5175 | 3,493 | anyplace-lib-android | MIT License |
app/src/main/java/tech/soit/quiet/ui/fragment/home/MainMusicFragment.kt | boyan01 | 114,945,726 | false | null | package tech.soit.quiet.ui.fragment.home
import android.app.Activity
import android.content.Intent
import android.graphics.drawable.ColorDrawable
import android.os.Bundle
import android.view.View
import android.widget.Toast
import androidx.recyclerview.widget.RecyclerView
import kotlinx.android.synthetic.main.content_main_music_user_info.*
import kotlinx.android.synthetic.main.fragment_main_music.*
import kotlinx.android.synthetic.main.item_main_navigation.view.*
import kotlinx.coroutines.launch
import me.drakeet.multitype.MultiTypeAdapter
import tech.soit.quiet.R
import tech.soit.quiet.model.vo.PlayListDetail
import tech.soit.quiet.model.vo.User
import tech.soit.quiet.ui.activity.LatestPlayListActivity
import tech.soit.quiet.ui.activity.local.LocalMusicActivity
import tech.soit.quiet.ui.activity.user.LoginActivity
import tech.soit.quiet.ui.fragment.base.BaseFragment
import tech.soit.quiet.ui.fragment.home.cloud.PlayListViewBinder
import tech.soit.quiet.ui.fragment.home.viewmodel.MainMusicViewModel
import tech.soit.quiet.ui.view.CircleOutlineProvider
import tech.soit.quiet.utils.annotation.LayoutId
import tech.soit.quiet.utils.component.ImageLoader
import tech.soit.quiet.utils.component.log
import tech.soit.quiet.utils.component.support.color
import tech.soit.quiet.utils.component.support.dimen
import tech.soit.quiet.utils.submit
import tech.soit.quiet.utils.withBinder
import tech.soit.quiet.utils.withEmptyBinder
import tech.soit.quiet.utils.withLoadingBinder
/**
* main Fragment of music
*/
@LayoutId(R.layout.fragment_main_music)
class MainMusicFragment : BaseFragment() {
companion object {
private const val REQUEST_LOGIN = 1203
}
private val mainMusicViewMode by lazyViewModel<MainMusicViewModel>()
private val neteaseRepository get() = mainMusicViewMode.getNeteaseRepository()
private lateinit var adapter: MultiTypeAdapter
private var rangeCreated = IntRange(0, 0)
private var rangeCollection = IntRange(0, 0)
private var positionCollectionStart = 0
private var isLogin = false
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
//init navigation items
initNavigation()
//init recycler view
adapter = MultiTypeAdapter()
.withBinder(PlayListViewBinder())
.withEmptyBinder()
.withLoadingBinder()
recyclerView.adapter = adapter
recyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
private var totalY = 0
override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
totalY += dy
val offset = totalY.toFloat() / (rangeCollection.last - recyclerView.height)
tabLayoutPlayLists.setScrollPosition(0, offset, true)
}
})
tabLayoutPlayLists.touchables.forEach { it.isClickable = false }
loadData()
}
private fun loadData() {
launch {
val user = neteaseRepository.getLoginUser()
checkUser(user)
user ?: return@launch
val playLists: List<PlayListDetail>
try {
playLists = neteaseRepository.getUserPlayerList(user.getId())
computePlayListRange(playLists, user.getId())
} catch (e: Exception) {
Toast.makeText(requireContext(), e.message ?: "error", Toast.LENGTH_SHORT).show()
return@launch
}
adapter.submit(playLists)
}
}
private fun computePlayListRange(playLists: List<PlayListDetail>, userId: Long) {
val createdCount = playLists.count { it.getCreator().getId() == userId }
positionCollectionStart = createdCount //reset started position of collection
val height = dimen(R.dimen.height_item_play_list).toInt()
rangeCreated = 0..(createdCount * height)
rangeCollection = (createdCount * height)..(playLists.size * height)
}
/**
* check if user has been login
*/
private fun checkUser(user: User?) {
isLogin = user != null
if (user == null) {
imageUserAvatar.setImageDrawable(ColorDrawable(color(R.color.color_gray)))
textUserNickname.setText(R.string.user_not_login)
} else {
ImageLoader.with(this).load(user.getAvatarUrl()).into(imageUserAvatar)
textUserNickname.text = user.getNickName()
}
}
private fun initNavigation() {
imageUserAvatar.outlineProvider = CircleOutlineProvider()
imageUserAvatar.clipToOutline = true
layoutUserInfo.setOnClickListener {
if (!isLogin) {
startActivityForResult(Intent(requireContext(), LoginActivity::class.java), REQUEST_LOGIN)
} else {
log { "has been login" }
}
}
with(navLayoutLocal) {
imageIcon.setImageResource(R.drawable.ic_music_note_black_24dp)
textTitle.setText(R.string.nav_local_music)
setOnClickListener {
startActivity(Intent(requireActivity(), LocalMusicActivity::class.java))
}
}
with(navLayoutHistory) {
imageIcon.setImageResource(R.drawable.ic_history_black_24dp)
textTitle.setText(R.string.nav_history)
setOnClickListener {
startActivity(Intent(requireActivity(), LatestPlayListActivity::class.java))
}
}
with(navLayoutDownload) {
imageIcon.setImageResource(R.drawable.ic_file_download_black_24dp)
textTitle.setText(R.string.nav_download)
}
with(navLayoutCollection) {
imageIcon.setImageResource(R.drawable.ic_collections_black_24dp)
textTitle.setText(R.string.nav_collection)
}
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
if (requestCode == REQUEST_LOGIN && resultCode == Activity.RESULT_OK) {
loadData()
}
}
} | 0 | Kotlin | 3 | 27 | 0ba7211c39bf6d144dcda8f79a0d10f4e57b2208 | 6,138 | MusicPlayer | Apache License 2.0 |
aide/src/test/kotlin/team/duckie/quackquack/aide/rule/AideModifiers.kt | duckie-team | 523,387,054 | false | null | /*
* Designed and developed by Duckie Team 2023.
*
* Licensed under the MIT.
* Please see full license: https://github.com/duckie-team/quack-quack-android/blob/main/LICENSE
*/
package team.duckie.quackquack.aide.rule
val testAideModifiers: Map<String, List<String>> = run {
val aide = mutableMapOf<String, List<String>>()
aide["text"] = listOf("span")
aide["_span"] = emptyList()
aide["_longParameters"] = emptyList()
aide["_onClick"] = emptyList()
aide
}
| 32 | Kotlin | 4 | 51 | 57f7c8bf7d979363c072916aa300b2b50756befc | 477 | quack-quack-android | MIT License |
src/main/kotlin/com/mark/netrune/net/netty4/DefaultServerBootstrapFactory.kt | Mark7625 | 641,050,293 | false | null | package org.jire.netrune.net.server.netty4
object DefaultServerBootstrapFactory : ServerBootstrapFactory
| 1 | Kotlin | 1 | 1 | 8cff984c258cf12b440e30626b60dd3f36aa9824 | 106 | Osrs-Data-packer | MIT License |
app/src/main/java/com/andriawan/askme/utils/extensions/NavigationExt.kt | andriawan24 | 549,668,878 | false | {"Kotlin": 143143} | package com.andriawan.askme.utils.extensions
import androidx.navigation.NavHostController
import com.andriawan.askme.utils.Constants
import com.andriawan.askme.utils.None
import com.andriawan.askme.utils.SingleEvents
fun NavHostController.handleNavigationWithSingleEvent(
event: SingleEvents<None>,
destination: String,
popUpToRoute: String = Constants.EMPTY,
inclusive: Boolean = false,
launchSingleTop: Boolean = false
) {
event.getContentIfNotHandled()?.let {
this.navigate(destination) {
this.launchSingleTop = launchSingleTop
popUpTo(popUpToRoute) {
this.inclusive = inclusive
}
}
}
}
fun NavHostController.handleNavigation(
destination: String,
popUpToRoute: String = Constants.EMPTY,
inclusive: Boolean = false,
launchSingleTop: Boolean = false
) {
this.navigate(destination) {
this.launchSingleTop = launchSingleTop
popUpTo(popUpToRoute) {
this.inclusive = inclusive
}
}
} | 0 | Kotlin | 0 | 0 | 45fa98892eead805de9ce26a4b0c5655fe79f649 | 1,039 | ask-me-android | MIT License |
core/src/main/java/id/rifqipadisiliwangi/core/domain/model/checkout/CheckoutDataClass.kt | Rifqips | 767,860,717 | false | {"Kotlin": 316033} | package id.rifqipadisiliwangi.core.domain.model.checkout
import android.os.Parcelable
import androidx.annotation.Keep
import kotlinx.android.parcel.Parcelize
@Keep
@Parcelize
data class CheckoutDataClass(
var productId: String,
var productImage: String,
var productName: String,
var productVariant: String,
var productStock: Int,
var productPrice: Int,
var productQuantity: Int
) : Parcelable
@Keep
@Parcelize
data class ListCheckout(
val listCheckout: List<CheckoutDataClass>
) : Parcelable | 0 | Kotlin | 0 | 0 | fbbaccd6573958fb817e25fb6d7e1761ef0c7bac | 526 | TokoPaerbe | MIT License |
data/src/main/java/com/lefarmico/data/mapper/WorkoutRecordsDataMapper.kt | LeFarmico | 382,809,671 | false | null | package com.lefarmico.data.mapper
import com.lefarmico.data.db.entity.WorkoutRecordsData
import com.lefarmico.domain.entity.WorkoutRecordsDto
import java.lang.IllegalArgumentException
fun WorkoutRecordsDto.Exercise.toData() = WorkoutRecordsData.Exercise(
id = id,
exerciseName = exerciseName,
workoutId = workoutId,
libraryId = libraryId
)
fun WorkoutRecordsDto.Set.toData() = WorkoutRecordsData.Set(
id = id,
exerciseId = exerciseId,
setNumber = setNumber,
weight = weight,
reps = reps,
measureType = measureType.toData()
)
fun WorkoutRecordsDto.Workout.toData() = WorkoutRecordsData.Workout(
id = id,
date = date,
title = title,
time = time
)
fun List<WorkoutRecordsDto.Exercise>.toData() = this.map { it.toData() }
@JvmName("WorkoutRecordsDtoSetToData")
fun List<WorkoutRecordsDto.Set>.toData() = this.map { it.toData() }
fun WorkoutRecordsDto.MeasureType.toData(): WorkoutRecordsData.MeasureType {
return when (this.typeNumber) {
1 -> WorkoutRecordsData.MeasureType.KILO
2 -> WorkoutRecordsData.MeasureType.LB
else -> throw (IllegalArgumentException())
}
}
| 0 | Kotlin | 0 | 3 | e1fa8a81aefcb6131b704f787b1fa9b5518a6735 | 1,156 | GymSupporter | Apache License 2.0 |
data/src/main/java/com/lefarmico/data/mapper/WorkoutRecordsDataMapper.kt | LeFarmico | 382,809,671 | false | null | package com.lefarmico.data.mapper
import com.lefarmico.data.db.entity.WorkoutRecordsData
import com.lefarmico.domain.entity.WorkoutRecordsDto
import java.lang.IllegalArgumentException
fun WorkoutRecordsDto.Exercise.toData() = WorkoutRecordsData.Exercise(
id = id,
exerciseName = exerciseName,
workoutId = workoutId,
libraryId = libraryId
)
fun WorkoutRecordsDto.Set.toData() = WorkoutRecordsData.Set(
id = id,
exerciseId = exerciseId,
setNumber = setNumber,
weight = weight,
reps = reps,
measureType = measureType.toData()
)
fun WorkoutRecordsDto.Workout.toData() = WorkoutRecordsData.Workout(
id = id,
date = date,
title = title,
time = time
)
fun List<WorkoutRecordsDto.Exercise>.toData() = this.map { it.toData() }
@JvmName("WorkoutRecordsDtoSetToData")
fun List<WorkoutRecordsDto.Set>.toData() = this.map { it.toData() }
fun WorkoutRecordsDto.MeasureType.toData(): WorkoutRecordsData.MeasureType {
return when (this.typeNumber) {
1 -> WorkoutRecordsData.MeasureType.KILO
2 -> WorkoutRecordsData.MeasureType.LB
else -> throw (IllegalArgumentException())
}
}
| 0 | Kotlin | 0 | 3 | e1fa8a81aefcb6131b704f787b1fa9b5518a6735 | 1,156 | GymSupporter | Apache License 2.0 |
src/test/kotlin/core/router/RequestHandlerImplTest.kt | johnGachihi | 371,629,012 | false | null | package core.router
import core.Response
import core.exceptionhandling.ExceptionHandler
import core.requesthandling.RequestHandlerEventManager
import core.requesthandling.RequestHandlerImpl
import createMockRequest
import createMockResponse
import io.mockk.every
import io.mockk.impl.annotations.InjectMockKs
import io.mockk.impl.annotations.RelaxedMockK
import io.mockk.junit5.MockKExtension
import io.mockk.mockk
import io.mockk.verify
import io.mockk.verifyOrder
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
@ExtendWith(MockKExtension::class)
internal class RequestHandlerImplTest {
@RelaxedMockK
private lateinit var eventManager: RequestHandlerEventManager
@RelaxedMockK
private lateinit var endpointFactory: EndpointFactory
@RelaxedMockK
private lateinit var exceptionHandler: ExceptionHandler
@InjectMockKs
private lateinit var requestHandler: RequestHandlerImpl
@Test
fun `Uses EndpointFactory to get Endpoint using the received Request's action-code`() {
val actionCode = 192
val request = createMockRequest(withActionCode = actionCode)
requestHandler.handleRequest(request)
verify(exactly = 1) { endpointFactory.getEndpoint(actionCode) }
}
@Test
fun `Uses the Endpoint returned by EndpointFactory to handle the received Request`() {
val endpoint = mockk<Endpoint>(relaxed = true)
every { endpointFactory.getEndpoint(any()) } returns endpoint
val request = createMockRequest()
requestHandler.handleRequest(request)
verify(exactly = 1) { endpoint.handleRequest(request) }
}
@Test
fun `When exception is thrown when handling a Request, then ExceptionHandler is passed the exception thrown and Request being handled`() {
val thrownException = Exception()
makeRequestHandlingThrowException(exception = thrownException)
val requestBeingHandled = createMockRequest()
requestHandler.handleRequest(requestBeingHandled)
verify(exactly = 1) { exceptionHandler.handleException(thrownException, requestBeingHandled) }
}
@Test
fun `When exception is thrown when handling a Request, the ExceptionHandler is used to create the returned Response`() {
makeRequestHandlingThrowException()
val responseFromExceptionHandler = createMockResponse()
makeExceptionHandlerReturn(responseFromExceptionHandler)
assertRequestHandlerReturns(responseFromExceptionHandler)
}
@Test
fun `When Request is handled successfully, then the used Endpoint's Response is returned`() {
val endpoint = mockk<Endpoint>(relaxed = true)
val responseFromEndpoint = createMockResponse()
every { endpoint.handleRequest(any()) } returns responseFromEndpoint
every { endpointFactory.getEndpoint(any()) } returns endpoint
assertRequestHandlerReturns(responseFromEndpoint)
}
@Test
fun `Publishes 'RequestReceived' event, before attempting to handle request`() {
requestHandler.handleRequest(createMockRequest())
verifyOrder {
eventManager.notifyRequestReceived()
endpointFactory.getEndpoint(any())
}
}
@Test
fun `Publishes 'RequestHandled' event, after Request is handled`() {
requestHandler.handleRequest(createMockRequest())
verifyOrder {
endpointFactory.getEndpoint(any())
eventManager.notifyRequestHandled()
}
}
@Test
@DisplayName(
"When request handling fails, the 'RequestHandledExceptionally'" +
"event is published after the request-handling attempt"
)
fun `test RequestHandledExceptionally event published`() {
makeRequestHandlingThrowException()
requestHandler.handleRequest(createMockRequest())
verifyOrder {
endpointFactory.getEndpoint(any())
eventManager.notifyRequestHandleExceptionally()
}
}
private fun makeRequestHandlingThrowException(exception: Exception = Exception()) {
every { endpointFactory.getEndpoint(any()) } throws exception
}
private fun makeExceptionHandlerReturn(returns: Response = createMockResponse()) {
every { exceptionHandler.handleException(any(), any()) } returns returns
}
private fun assertRequestHandlerReturns(response: Response) {
assertEquals(
response,
requestHandler.handleRequest(createMockRequest())
)
}
} | 0 | Kotlin | 0 | 0 | 3ff46ac42048bde5e4576ae34e19a6050b53db87 | 4,650 | Parking-Netty | Apache License 2.0 |
app/src/main/java/io/traxa/App.kt | chrisinvb | 517,052,842 | false | {"Kotlin": 213490, "Java": 18186} | package io.traxa
import android.app.Application
import android.util.Log
import io.traxa.models.AwsConfiguration
import io.traxa.modules.androidModule
import io.traxa.modules.networkModule
import io.traxa.modules.persistenceModule
import io.traxa.modules.processingModule
import io.traxa.persistence.AppDatabase
import io.traxa.repositories.PlayerTokenRepository
import io.traxa.services.Prefs
import io.traxa.services.network.AwsService
import io.traxa.services.network.StardustService
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import org.koin.android.ext.android.inject
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.startKoin
import java.util.*
class App : Application() {
private val awsService: AwsService by inject()
private val db: AppDatabase by inject()
private val tokenRepository: PlayerTokenRepository by inject()
private val stardustService: StardustService by inject()
private val prefs: Prefs by inject()
override fun onCreate() {
super.onCreate()
startKoin {
androidContext(this@App)
modules(
processingModule,
networkModule,
persistenceModule,
androidModule
)
}
awsService.setup(AwsConfiguration(
BuildConfig.awsRegion,
BuildConfig.awsBucketName,
BuildConfig.awsAccessKey,
BuildConfig.awsSecretKey
))
CoroutineScope(Dispatchers.IO).launch {
AppDatabase.initialize(db)
//Update tokens
if(prefs.getPlayerId() != null){
Log.d("App", "PlayerId: " + prefs.getPlayerId())
tokenRepository.getPlayerTokens()
}
else {
val uuid = prefs.getPlayerUUID() ?: UUID.randomUUID().toString().also {
prefs.setPlayerUUID(it)
}
val playerId = stardustService.createPlayer(uuid)
if(playerId != null) prefs.setPlayerId(playerId)
}
}
}
} | 0 | Kotlin | 0 | 0 | a21ba2aa3dfa3056083b0f72c644c913c3df45b8 | 2,159 | traxaio_android_polygon_filecoin | MIT License |
app/src/main/java/dev/devlopment/chater/Screens/ChatMessageItem.kt | Devesh-Ingale | 779,638,105 | false | {"Kotlin": 108520} | package dev.devlopment.chater.Screens
import android.util.Log
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.clickable
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Add
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.material3.Divider
import androidx.compose.material3.DividerDefaults
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FloatingActionButton
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
import dev.devlopment.chater.R
import dev.devlopment.chater.Repository.Result
import dev.devlopment.chater.Repository.Room
import dev.devlopment.chater.ViewModels.RoomViewModel
import dev.devlopment.chater.ui.theme.focusedTextFieldText
import dev.devlopment.chater.ui.theme.textFieldContainer
import dev.devlopment.chater.ui.theme.unfocusedTextFieldText
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun ChatRoomListScreen(
roomViewModel: RoomViewModel = viewModel(),
onJoinClicked: (Room) -> Unit,
onAiClicked: () -> Unit
) {
val rooms by roomViewModel.rooms.observeAsState(emptyList())
Log.d("ChatRoomListScreen", "Observed rooms: $rooms") // Add this line
var showDialog by remember { mutableStateOf(false) }
var name by remember { mutableStateOf("") }
var searchText by remember { mutableStateOf("") }
var joinRoomDialog by remember { mutableStateOf(false) }
var roomId by remember { mutableStateOf("") }
val createRoomResult by roomViewModel.createRoomResult.observeAsState()
createRoomResult?.let { result ->
when (result) {
is dev.devlopment.chater.Repository.Result.Success -> {
// Room creation succeeded, hide dialog and clear input
showDialog = false
name = ""
}
is Result.Error -> {
// Handle the error, maybe show a Toast or a Snackbar
Log.e("ChatRoomListScreen", "Error creating room: ${result.exception.message}")
}
is dev.devlopment.chater.Repository.Result.Error -> TODO()
is dev.devlopment.chater.Repository.Result.Success -> TODO()
}
}
val filteredRooms = rooms.filter { it.name.contains(searchText, ignoreCase = true) }
Log.d("ChatRoomListScreen", "Filtered rooms: $filteredRooms") // Add this line
val background: Color = if (isSystemInDarkTheme()) Color(0xFF1E293B) else Color(0xFFBFDBFE)
val uiColor: Color = if (isSystemInDarkTheme()) Color.White else Color.Black
Box(modifier = Modifier.fillMaxSize()) {
Column(modifier = Modifier.fillMaxSize()) {
Text(
"Chat Rooms",
style = MaterialTheme.typography.headlineLarge,
modifier = Modifier
.background(background, shape = RoundedCornerShape(5.dp))
.fillMaxWidth()
.padding(all = 15.dp),
color = uiColor
)
Spacer(modifier = Modifier.height(16.dp))
TextField(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
.border(BorderStroke(0.5.dp, color = uiColor), shape = RoundedCornerShape(20.dp)),
value = searchText,
onValueChange = { searchText = it },
label = {
Text(
text = "Search Rooms",
style = MaterialTheme.typography.labelMedium,
color = uiColor
)
},
colors = TextFieldDefaults.textFieldColors(
unfocusedLabelColor = MaterialTheme.colorScheme.unfocusedTextFieldText,
focusedLabelColor = MaterialTheme.colorScheme.focusedTextFieldText
),
trailingIcon = {
Icon(
painter = painterResource(id = if (isSystemInDarkTheme()) R.drawable.baseline_search_24_dark else R.drawable.baseline_search_24),
contentDescription = "search"
)
}
)
Spacer(modifier = Modifier.height(16.dp))
AiItem(onAiClicked = onAiClicked)
LazyColumn {
items(filteredRooms) { room ->
RoomItem(room = room, onJoinClicked = { onJoinClicked(room) })
}
}
Spacer(modifier = Modifier.height(16.dp))
Button(onClick = { showDialog = true }, modifier = Modifier.fillMaxWidth()) {
Text("Create Room")
}
if (showDialog) {
AlertDialog(
onDismissRequest = { showDialog = false },
title = { Text("Create a new room") },
text = {
OutlinedTextField(
value = name,
onValueChange = { name = it },
singleLine = true,
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
)
},
confirmButton = {
Button(onClick = {
if (name.isNotBlank()) {
roomViewModel.createRoom(name)
// The dialog will be dismissed based on the observation of `createRoomResult`
}
}) {
Text("Add")
}
},
dismissButton = {
Button(onClick = { showDialog = false }) {
Text("Cancel")
}
}
)
}
}
FloatingActionButton(
onClick = { joinRoomDialog = true },
modifier = Modifier.align(Alignment.BottomEnd).padding(16.dp)
) {
Icon(imageVector = Icons.Default.Add, contentDescription = "Join Room")
}
}
if (joinRoomDialog) {
AlertDialog(
onDismissRequest = { joinRoomDialog = false },
title = { Text(text = "Join Room") },
text = {
Column {
Text(text = "Enter Room ID")
TextField(value = roomId, onValueChange = { roomId = it })
}
},
confirmButton = {
Button(onClick = {
roomViewModel.requestToJoinRoom(roomId)
joinRoomDialog = false
}) {
Text(text = "Send Request")
}
},
dismissButton = {
Button(onClick = { joinRoomDialog = false }) {
Text(text = "Cancel")
}
}
)
}
}
@Composable
fun RoomItem(room: Room, onJoinClicked: (Room) -> Unit) {
val uiColor: Color = if (isSystemInDarkTheme()) Color.White else Color.Black
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
.clickable { onJoinClicked(room) }
.background(color = MaterialTheme.colorScheme.textFieldContainer)
.clip(RoundedCornerShape(20.dp)),
horizontalArrangement = Arrangement.Start,
verticalAlignment = Alignment.CenterVertically
) {
Spacer(modifier = Modifier.width(20.dp))
Image(
painter = painterResource(id = R.drawable.baseline_person_24),
contentDescription = "Room Image",
modifier = Modifier
.size(25.dp)
.clip(RoundedCornerShape(8.dp))
)
Spacer(modifier = Modifier.width(20.dp))
Column {
Text(
text = room.name,
style = MaterialTheme.typography.headlineMedium,
color = MaterialTheme.colorScheme.focusedTextFieldText
)
Text(
text = room.name,
style = MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Light),
color = MaterialTheme.colorScheme.focusedTextFieldText
)
}
Spacer(modifier = Modifier.weight(1f))
Text(
text = room.name,
style = MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Light),
color = MaterialTheme.colorScheme.focusedTextFieldText
)
Spacer(modifier = Modifier.width(20.dp))
}
Divider(modifier = Modifier.padding(8.dp), thickness = DividerDefaults.Thickness, color = uiColor)
}
@Composable
fun AiItem(onAiClicked: () -> Unit) {
val uiColor: Color = if (isSystemInDarkTheme()) Color.White else Color.Black
Row(
modifier = Modifier
.fillMaxWidth()
.padding(8.dp)
.clickable { onAiClicked() }
.background(color = MaterialTheme.colorScheme.textFieldContainer)
.clip(RoundedCornerShape(20.dp)),
horizontalArrangement = Arrangement.Start,
verticalAlignment = Alignment.CenterVertically
) {
Spacer(modifier = Modifier.width(20.dp))
Image(
painter = painterResource(id = R.drawable.baseline_person_24),
contentDescription = "Room Image",
modifier = Modifier
.size(25.dp)
.clip(RoundedCornerShape(8.dp))
)
Spacer(modifier = Modifier.width(20.dp))
Column {
Text(
text = "Ai Assistant",
style = MaterialTheme.typography.headlineMedium,
color = MaterialTheme.colorScheme.focusedTextFieldText
)
Text(
text = "Chat with Ai Assistant",
style = MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Light),
color = MaterialTheme.colorScheme.focusedTextFieldText
)
}
Spacer(modifier = Modifier.weight(1f))
Text(
text = "Join Room",
style = MaterialTheme.typography.labelMedium.copy(fontWeight = FontWeight.Light),
color = MaterialTheme.colorScheme.focusedTextFieldText
)
Spacer(modifier = Modifier.width(20.dp))
}
Divider(modifier = Modifier.padding(8.dp), thickness = DividerDefaults.Thickness, color = uiColor)
}
@Preview(showBackground = true)
@Composable
fun RoomItemPreview() {
RoomItem(room = Room("id.com","Name"),{})
} | 0 | Kotlin | 0 | 0 | d83e85e6e24ddc40d91e8a61a2a326efe4262c09 | 12,564 | Talkify | MIT License |
src/com/android/adblib/impl/AdbBufferedInputChannelImpl.kt | DevOculus-Meta-Quest | 831,217,289 | false | {"Kotlin": 1110908, "Starlark": 15263} | /*
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.adblib.impl
import com.android.adblib.AdbInputChannel
import com.android.adblib.AdbSession
import com.android.adblib.adbLogger
import com.android.adblib.read
import java.io.BufferedInputStream
import java.io.InputStream
import java.nio.ByteBuffer
import java.util.concurrent.TimeUnit
import kotlin.math.min
/**
* Implementation of an [AdbInputChannel] that reads data from another [AdbInputChannel]
* using an internal [ByteBuffer] of the given buffer size.
*
* This class is similar to [BufferedInputStream], but for [AdbInputChannel] instead of
* [InputStream].
*/
internal class AdbBufferedInputChannelImpl(
session: AdbSession,
private val input: AdbInputChannel,
bufferSize: Int = DEFAULT_BUFFER_SIZE,
private val closeInputChannel: Boolean = true
) : AdbInputChannel {
private val logger = adbLogger(session)
/**
* The bytes that were read from [input], starting at position `0` up to position
* [ByteBuffer.limit].
*/
private val inputBuffer = ByteBuffer.allocate(bufferSize).limit(0)
/**
* [ByteBuffer.slice] of [inputBuffer] that contains bytes available for the next [read]
* operations(s), starting at [ByteBuffer.position] up to [ByteBuffer.limit].
*
* Note: [inputBuffer] and [inputBufferSlice] always have the same [ByteBuffer.limit]
* and [ByteBuffer.capacity].
*/
private val inputBufferSlice = inputBuffer.duplicate()
init {
assertInputBufferIsValid()
}
override suspend fun readBuffer(buffer: ByteBuffer, timeout: Long, unit: TimeUnit) {
// Fast path: internal buffer contains data
if (inputBufferSlice.remaining() > 0) {
copyInputBufferTo(buffer).also { count ->
logger.verbose { "read: Copied $count bytes from input '$input'" }
}
return
}
readAndCopyInputBufferTo(buffer, timeout, unit)
}
override suspend fun readExactly(buffer: ByteBuffer, timeout: Long, unit: TimeUnit) {
// Fast path: internal buffer contains enough data to fill [buffer]
if (inputBufferSlice.remaining() >= buffer.remaining()) {
copyInputBufferTo(buffer).also { count ->
logger.verbose { "readExactly: Copied $count bytes from input '$input'" }
}
assert(buffer.remaining() == 0)
return
}
super.readExactly(buffer, timeout, unit)
}
private fun copyInputBufferTo(buffer: ByteBuffer): Int {
val count = min(inputBufferSlice.remaining(), buffer.remaining())
val savedLimit = inputBufferSlice.limit()
inputBufferSlice.limit(inputBufferSlice.position() + count)
buffer.put(inputBufferSlice)
inputBufferSlice.limit(savedLimit)
return count
}
private suspend fun readAndCopyInputBufferTo(buffer: ByteBuffer, timeout: Long, unit: TimeUnit): Int {
assertInputBufferIsValid()
inputBuffer.clear()
inputBufferSlice.clear()
val count = input.read(inputBuffer, timeout, unit)
logger.verbose { "read: Read $count bytes from input '$input'" }
if (count <= 0) {
return count
}
inputBuffer.flip()
inputBufferSlice.limit(count)
assertInputBufferIsValid()
assert(inputBuffer.remaining() > 0)
assert(inputBufferSlice.remaining() > 0)
assert(inputBufferSlice.remaining() == inputBuffer.remaining())
return copyInputBufferTo(buffer)
}
@Suppress("NOTHING_TO_INLINE")
private inline fun assertInputBufferIsValid() {
assert(inputBuffer.position() <= inputBufferSlice.position())
assert(inputBuffer.limit() == inputBufferSlice.limit())
assert(inputBuffer.capacity() == inputBufferSlice.capacity())
}
override fun close() {
if (closeInputChannel) {
input.close()
}
}
}
| 0 | Kotlin | 0 | 1 | 417de93b668ebdae1aa5d822616e3e6b17b4a2e9 | 4,536 | AdbLib-Google-PlatformTools | MIT License |
app/src/main/java/com/jeroenmols/snap/PhotosFragment.kt | JeroenMols | 158,918,382 | false | null | package com.jeroenmols.snap
import android.os.Bundle
import android.view.*
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.SearchView
import androidx.fragment.app.Fragment
import androidx.lifecycle.Observer
import androidx.lifecycle.ViewModelProviders
import androidx.recyclerview.widget.GridLayoutManager
import com.jakewharton.rxbinding3.appcompat.queryTextChanges
import com.jeroenmols.snap.common.data.Photo
import io.reactivex.disposables.CompositeDisposable
import kotlinx.android.synthetic.main.fragment_photos.*
import java.util.concurrent.TimeUnit
class PhotosFragment : Fragment() {
lateinit var viewModel: PhotosViewModel
lateinit var adapter: PhotosAdapter
val disposables = CompositeDisposable()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel = ViewModelProviders.of(this, PhotosViewModelFactory()).get(PhotosViewModel::class.java)
adapter = PhotosAdapter()
viewModel.photos.observe(this, Observer<List<Photo>> { photos -> adapter.photos = photos })
setHasOptionsMenu(true)
}
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
return inflater.inflate(R.layout.fragment_photos, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
(activity as AppCompatActivity).setSupportActionBar(photos_toolbar)
photos_list.adapter = adapter
photos_list.layoutManager = GridLayoutManager(activity, 2)
}
override fun onCreateOptionsMenu(menu: Menu?, inflater: MenuInflater?) {
inflater!!.inflate(R.menu.photos, menu)
val searchView = menu!!.findItem(R.id.action_search)!!.actionView as SearchView
disposables.add(searchView.queryTextChanges().skipInitialValue()
.debounce(300, TimeUnit.MILLISECONDS)
.subscribe { viewModel.search(it.toString()) })
}
override fun onDestroyView() {
super.onDestroyView()
disposables.clear()
}
}
| 0 | Kotlin | 0 | 2 | a3d0ca55f19438d9aa565772fcd06737f1891d44 | 2,106 | Snap | Apache License 2.0 |
rounded/src/commonMain/kotlin/me/localx/icons/rounded/outline/WrenchAlt.kt | localhostov | 808,861,591 | false | {"Kotlin": 79430321, "HTML": 331, "CSS": 102} | package me.localx.icons.rounded.outline
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.PathFillType.Companion.NonZero
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.StrokeCap.Companion.Butt
import androidx.compose.ui.graphics.StrokeJoin.Companion.Miter
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.graphics.vector.ImageVector.Builder
import androidx.compose.ui.graphics.vector.path
import androidx.compose.ui.unit.dp
import me.localx.icons.rounded.Icons
public val Icons.Outline.WrenchAlt: ImageVector
get() {
if (_wrenchAlt != null) {
return _wrenchAlt!!
}
_wrenchAlt = Builder(name = "WrenchAlt", defaultWidth = 24.0.dp, defaultHeight = 24.0.dp,
viewportWidth = 24.0f, viewportHeight = 24.0f).apply {
path(fill = SolidColor(Color(0xFF000000)), stroke = null, strokeLineWidth = 0.0f,
strokeLineCap = Butt, strokeLineJoin = Miter, strokeLineMiter = 4.0f,
pathFillType = NonZero) {
moveToRelative(3.688f, 24.0f)
curveToRelative(-0.032f, 0.0f, -0.063f, 0.0f, -0.095f, 0.0f)
curveToRelative(-1.022f, -0.027f, -1.963f, -0.462f, -2.649f, -1.224f)
curveToRelative(-1.269f, -1.409f, -1.157f, -3.784f, 0.244f, -5.185f)
lineToRelative(5.868f, -5.867f)
curveToRelative(0.253f, -0.254f, 0.344f, -0.631f, 0.241f, -1.009f)
curveToRelative(-0.358f, -1.318f, -0.393f, -2.676f, -0.102f, -4.036f)
curveTo(7.903f, 3.364f, 10.626f, 0.735f, 13.972f, 0.137f)
curveToRelative(1.006f, -0.18f, 2.015f, -0.184f, 3.002f, -0.007f)
curveToRelative(0.731f, 0.129f, 1.299f, 0.625f, 1.52f, 1.325f)
curveToRelative(0.251f, 0.799f, -0.003f, 1.681f, -0.682f, 2.359f)
lineToRelative(-2.247f, 2.217f)
curveToRelative(-0.658f, 0.658f, -0.758f, 1.69f, -0.222f, 2.345f)
curveToRelative(0.308f, 0.378f, 0.742f, 0.598f, 1.222f, 0.622f)
curveToRelative(0.472f, 0.02f, 0.936f, -0.155f, 1.271f, -0.489f)
lineToRelative(2.58f, -2.55f)
curveToRelative(0.539f, -0.539f, 1.332f, -0.735f, 2.07f, -0.501f)
curveToRelative(0.723f, 0.227f, 1.254f, 0.828f, 1.385f, 1.567f)
horizontalLineToRelative(0.0f)
curveToRelative(0.175f, 0.987f, 0.172f, 1.998f, -0.007f, 3.003f)
curveToRelative(-0.6f, 3.347f, -3.229f, 6.07f, -6.544f, 6.777f)
curveToRelative(-1.363f, 0.291f, -2.721f, 0.256f, -4.036f, -0.103f)
curveToRelative(-0.377f, -0.104f, -0.754f, -0.012f, -1.008f, 0.241f)
lineToRelative(-5.976f, 5.975f)
curveToRelative(-0.69f, 0.69f, -1.637f, 1.081f, -2.612f, 1.081f)
close()
moveTo(15.61f, 1.993f)
curveToRelative(-0.422f, 0.0f, -0.854f, 0.035f, -1.286f, 0.112f)
curveToRelative(-2.554f, 0.457f, -4.634f, 2.463f, -5.174f, 4.991f)
curveToRelative(-0.224f, 1.045f, -0.198f, 2.086f, 0.076f, 3.093f)
curveToRelative(0.29f, 1.062f, 0.0f, 2.191f, -0.756f, 2.948f)
lineToRelative(-5.868f, 5.867f)
curveToRelative(-0.65f, 0.65f, -0.732f, 1.81f, -0.171f, 2.433f)
curveToRelative(0.315f, 0.35f, 0.747f, 0.55f, 1.215f, 0.562f)
curveToRelative(0.461f, 0.019f, 0.909f, -0.163f, 1.241f, -0.494f)
lineToRelative(5.975f, -5.975f)
curveToRelative(0.755f, -0.755f, 1.885f, -1.047f, 2.948f, -0.757f)
curveToRelative(1.004f, 0.274f, 2.045f, 0.3f, 3.093f, 0.076f)
curveToRelative(2.528f, -0.539f, 4.534f, -2.618f, 4.992f, -5.174f)
curveToRelative(0.138f, -0.772f, 0.14f, -1.547f, 0.006f, -2.301f)
verticalLineToRelative(-0.007f)
reflectiveCurveToRelative(-2.655f, 2.559f, -2.655f, 2.559f)
curveToRelative(-0.729f, 0.729f, -1.744f, 1.136f, -2.781f, 1.068f)
curveToRelative(-1.036f, -0.052f, -2.009f, -0.545f, -2.669f, -1.353f)
curveToRelative(-1.179f, -1.439f, -1.021f, -3.649f, 0.361f, -5.03f)
lineToRelative(2.247f, -2.217f)
curveToRelative(0.179f, -0.18f, 0.191f, -0.314f, 0.184f, -0.341f)
curveToRelative(-0.315f, -0.039f, -0.643f, -0.062f, -0.976f, -0.062f)
close()
}
}
.build()
return _wrenchAlt!!
}
private var _wrenchAlt: ImageVector? = null
| 1 | Kotlin | 0 | 5 | cbd8b510fca0e5e40e95498834f23ec73cc8f245 | 4,714 | icons | MIT License |
src/main/kotlin/uk/gov/justice/digital/hmpps/visitscheduler/dto/enums/UnFlagEventReason.kt | ministryofjustice | 409,259,375 | false | {"Kotlin": 1812446, "PLpgSQL": 179605, "FreeMarker": 14114, "Dockerfile": 1541, "Shell": 238} | package uk.gov.justice.digital.hmpps.visitscheduler.dto.enums
enum class UnFlagEventReason(val desc: String) {
VISIT_CANCELLED("visit-cancelled"),
VISIT_DATE_UPDATED("visit-date-updated"),
PRISON_EXCLUDE_DATE_REMOVED("prison-exclude-date-removed"),
NON_ASSOCIATION_REMOVED("non-association-removed"),
IGNORE_VISIT_NOTIFICATIONS("do-not-change"),
}
| 3 | Kotlin | 2 | 5 | 80ef5783b43f7c5abe1e7068f7e179b4cb945f16 | 359 | visit-scheduler | MIT License |
src/main/kotlin/viewmodel/graph/VertexViewModel.kt | spbu-coding-2023 | 790,907,560 | false | {"Kotlin": 164686, "Python": 12618, "Shell": 161} | package viewmodel.graph
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import model.graph.Vertex
class VertexViewModel<V>(
x: Dp = 0.dp,
y: Dp = 0.dp,
color: Color,
private val v: Vertex<V>,
val radius: Dp = 25.dp
) {
private var _x = mutableStateOf(x)
var x: Dp
get() = _x.value
set(value) {
_x.value = value
}
private var _y = mutableStateOf(y)
var y: Dp
get() = _y.value
set(value) {
_y.value = value
}
private var _color = mutableStateOf(color)
var color: Color
get() = _color.value
set(value) {
_color.value = value
}
fun onDrag(offset: Offset) {
_x.value += offset.x.dp
_y.value += offset.y.dp
}
} | 2 | Kotlin | 1 | 0 | b8586cc96d128b331bf6f9ac1141bec5a700b65e | 937 | graphs-graphs-6 | MIT License |
dokument/domain/src/main/kotlin/dokument/domain/journalføring/Journalpost.kt | navikt | 227,366,088 | false | {"Kotlin": 10119509, "Shell": 4388, "TSQL": 1233, "Dockerfile": 1209} | package dokument.domain.journalføring
import no.nav.su.se.bakover.common.journal.JournalpostId
/**
* Vår representasjon av en mottatt journalpost
*
* Se [no.nav.su.se.bakover.client.journalpost.Journalpost] for modell som vi henter fra Joark
*/
data class Journalpost(
val id: JournalpostId,
val tittel: String,
)
enum class JournalpostTema {
SUP,
}
enum class JournalpostStatus {
JOURNALFOERT,
FERDIGSTILT,
}
enum class JournalpostType {
INNKOMMENDE_DOKUMENT,
}
| 9 | Kotlin | 1 | 1 | 284ef4d20dc2823d96165e35831e05628824d07e | 496 | su-se-bakover | MIT License |
src/test/kotlin/com/vauthenticator/server/login/workflow/LoginWorkflowEngineTest.kt | VAuthenticator | 191,632,792 | false | {"Kotlin": 506983, "TypeScript": 45344, "HCL": 11742, "Python": 8943, "HTML": 6658, "JavaScript": 1917, "Shell": 1604, "Dockerfile": 1275} | package com.vauthenticator.server.login.workflow
import io.mockk.every
import io.mockk.impl.annotations.MockK
import io.mockk.junit5.MockKExtension
import io.mockk.just
import io.mockk.runs
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpSession
import org.junit.jupiter.api.Assertions.assertSame
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.springframework.security.web.authentication.AuthenticationSuccessHandler
@ExtendWith(MockKExtension::class)
class LoginWorkflowEngineTest {
@MockK
lateinit var defaultSuccessHandler: AuthenticationSuccessHandler
@MockK
lateinit var firstLoginWorkflowHandler: LoginWorkflowHandler
@MockK
lateinit var secondLoginWorkflowHandler: LoginWorkflowHandler
@MockK
lateinit var session: HttpSession
@MockK
lateinit var request: HttpServletRequest
@Test
fun `when a login workflow runs`() {
val loginWorkflowHandlers = listOf(
firstLoginWorkflowHandler,
secondLoginWorkflowHandler
)
every { session.getAttribute("CompositeLoginWorkflowEngine_index") } returns 0 andThen 1 andThen 2
every { session.setAttribute("CompositeLoginWorkflowEngine_index", 1) } just runs
every { session.setAttribute("CompositeLoginWorkflowEngine_index", 2) } just runs
val uut = CompositeLoginWorkflowEngine(loginWorkflowHandlers, defaultSuccessHandler)
assertSame(firstLoginWorkflowHandler, uut.workflowsNextHop(session))
assertSame(secondLoginWorkflowHandler, uut.workflowsNextHop(session))
assertSame(DefaultLoginWorkflowHandler, uut.workflowsNextHop(session))
}
} | 41 | Kotlin | 1 | 18 | da2b8ce40dffc85a9f2a1fdc72e18f2d35374aaa | 1,716 | vauthenticator | Apache License 2.0 |
feature/profile/src/main/java/ru/redmadrobot/profile/ProfileFragment.kt | bigman212 | 270,478,713 | false | null | package ru.redmadrobot.profile
import android.content.Context
import android.os.Bundle
import android.view.View
import androidx.fragment.app.viewModels
import androidx.lifecycle.ViewModelProvider
import ru.redmadrobot.common.base.BaseFragment
import ru.redmadrobot.common.data.profile.AccountDetails
import ru.redmadrobot.common.extensions.observe
import ru.redmadrobot.common.extensions.showLoading
import ru.redmadrobot.common.extensions.viewBinding
import ru.redmadrobot.common.vm.observeEvents
import ru.redmadrobot.profile.databinding.FragmentProfileBinding
import ru.redmadrobot.profile.di.component.ProfileComponent
import javax.inject.Inject
class ProfileFragment : BaseFragment(R.layout.fragment_profile) {
private val binding: FragmentProfileBinding by viewBinding()
@Inject
internal lateinit var viewModelFactory: ViewModelProvider.Factory
private val viewModel: ProfileViewModel by viewModels { viewModelFactory }
override fun onAttach(context: Context) {
super.onAttach(context)
initDagger()
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
initViewModel()
binding.btnLogout.setOnClickListener {
viewModel.onLogoutButtonClicked()
}
viewModel.loadAccountDetails()
}
private fun initDagger() {
ProfileComponent.init(appComponent).inject(this)
}
private fun initViewModel() {
observe(viewModel.viewState) { state ->
renderFetching(state.isFetching)
renderLogoutButtonState(state.isLogoutButtonEnabled)
renderAccount(state.account)
}
observeEvents(viewModel.events, ::onEvent)
}
private fun renderAccount(account: AccountDetails?) {
account?.let { accountDetails ->
binding.tvFullName.text = accountDetails.username
}
}
private fun renderFetching(isFetching: Boolean) {
binding.progressBar.showLoading(isFetching)
}
private fun renderLogoutButtonState(buttonState: Boolean) {
binding.btnLogout.isEnabled = buttonState
}
}
| 0 | Kotlin | 0 | 2 | c747d8cc8af6e508628e2bed268715483d451ad3 | 2,167 | movie-app-android | Apache License 2.0 |
app/src/main/java/de/redno/disabledlauncher/service/FileService.kt | voruti | 600,533,119 | false | null | package de.redno.disabledlauncher.service
import android.content.Context
import android.net.Uri
import android.util.Log
import com.fasterxml.jackson.databind.SerializationFeature
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import java.io.FileNotFoundException
object FileService {
private const val TAG = "FileService"
private const val MAIN_FILE_NAME = "mainFile.json"
private val objectMapper = jacksonObjectMapper()
.enable(SerializationFeature.INDENT_OUTPUT)
fun <T> readFile(context: Context, uri: String, clazz: Class<T>): T? {
if (uri == Datasource.INTERNAL_MAIN_FILE) {
touchInternalFile(context, MAIN_FILE_NAME, "{\"packages\":[]}")
}
try {
// open & read file:
val fileContent = if (uri == Datasource.INTERNAL_MAIN_FILE) {
context.openFileInput(MAIN_FILE_NAME)
.bufferedReader().use {
it.readText()
}
} else {
context.contentResolver.openInputStream(Uri.parse(uri))?.use {
it.bufferedReader().use {
it.readText()
}
}
}
return fileContent
// deserialize into object:
?.let { return objectMapper.readValue(it, clazz) }
} catch (e: Exception) {
Log.w(TAG, "Exception in readFile", e)
return null
}
}
private fun touchInternalFile(context: Context, fileName: String, content: String) {
try {
context.openFileInput(fileName).close()
} catch (_: FileNotFoundException) {
// file doesn't exist, creating it:
context.openFileOutput(fileName, Context.MODE_PRIVATE).use {
it.write(content.toByteArray())
}
}
}
fun <T> writeFile(context: Context, uri: String, obj: T): Boolean {
try {
// serialize object:
val jsonString = objectMapper.writeValueAsString(obj)
// open & write file:
if (uri == Datasource.INTERNAL_MAIN_FILE) {
context.openFileOutput(MAIN_FILE_NAME, Context.MODE_PRIVATE).use {
it.write(jsonString.toByteArray())
return true
}
} else {
context.contentResolver.openOutputStream(Uri.parse(uri), "wt")?.use {
it.bufferedWriter().use {
it.write(jsonString)
return true
}
}
}
} catch (e: Exception) {
Log.w(TAG, "Exception in writeFile", e)
}
return false
}
}
| 11 | null | 4 | 79 | 85d2e82853dd4a697fa4bd64412492d3981233a1 | 2,781 | DisabledLauncher | MIT License |
src/library/src/androidTest/java/jp/gr/java_conf/atle42/library/jsonholder/JSONHolderTestKt.kt | 4nswer2 | 87,273,645 | false | null | package jp.gr.java_conf.atle42.library.jsonholder
import android.support.test.runner.AndroidJUnit4
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
@RunWith(AndroidJUnit4::class)
class JSONHolderTestKt {
@Test
@Throws(Exception::class)
fun testAsRawJson() {
val holder = JSONHolder.parse(testRawJson)
assertEquals(answerRawJson, holder["json"].asRawJson())
}
@Test
@Throws(Exception::class)
fun testAsList() {
val holder = JSONHolder.parse(testRawJson)
assertEquals("{\"string\":\"long\",\"numerical\":9223372036854775807}", holder["json"]["json-array"].asList()[0].asRawJson())
assertEquals("hoge", holder["json"]["string-array"].asList()[0].asString())
assertEquals(true, holder["json"]["boolean-array"].asList()[0].asBoolean())
assertEquals(9223372036854775807L, holder["json"]["long-array"].asList()[0].asLong())
assertEquals(2147483647, holder["json"]["int-array"].asList()[0].asInt().toLong())
assertEquals(34.6786737, holder["json"]["double-array"].asList()[0].asDouble(), 0.0)
}
@Test
@Throws(Exception::class)
fun testHas() {
val holder = JSONHolder.parse(testRawJson)
assertEquals(true, holder.has("json"))
assertEquals(false, holder.has("jso"))
}
//--------------------------------------------------
// test rawJson
//--------------------------------------------------
private val testRawJson =
"{\n" +
" \"json\" : {\n" +
" \"string\" : \"test\",\n" +
" \"boolean\" : false,\n" +
" \"numerical\" : 65535,\n" +
" \"json-array\" : [\n" +
" { \"string\" : \"long\", \"numerical\" : 9223372036854775807 },\n" +
" { \"string\" : \"int\", \"numerical\" : 2147483647 },\n" +
" { \"string\" : \"double\", \"numerical\" : 34.6820959 }\n" +
" ],\n" +
" \"string-array\" : [\n" +
" \"hoge\",\n" +
" \"fuga\"\n" +
" ],\n" +
" \"boolean-array\" : [\n" +
" true,\n" +
" false\n" +
" ],\n" +
" \"long-array\" : [\n" +
" 9223372036854775807,\n" +
" 9223372036854775806\n" +
" ],\n" +
" \"int-array\" : [\n" +
" 2147483647,\n" +
" 2147483646\n" +
" ],\n" +
" \"double-array\" : [\n" +
" 34.6786737,\n" +
" 135.177107\n" +
" ]\n" +
" }\n" +
"}"
private val answerRawJson = "{\"string\":\"test\",\"boolean\":false,\"numerical\":65535,\"json-array\":[{\"string\":\"long\",\"numerical\":9223372036854775807},{\"string\":\"int\",\"numerical\":2147483647},{\"string\":\"double\",\"numerical\":34.6820959}],\"string-array\":[\"hoge\",\"fuga\"],\"boolean-array\":[true,false],\"long-array\":[9223372036854775807,9223372036854775806],\"int-array\":[2147483647,2147483646],\"double-array\":[34.6786737,135.177107]}"
} | 0 | Kotlin | 0 | 1 | b635d76023244ed24152d47d674904a11ba96864 | 2,802 | JSONHolder | MIT License |
bundle/base/apps/demo/server/services/samples/kotlin/remote-post-json.kts | netuno-org | 392,833,670 | false | {"JavaScript": 44861543, "Java": 4751473, "HTML": 2778101, "CSS": 1516576, "SCSS": 780640, "TypeScript": 342186, "Less": 329678, "CoffeeScript": 162930, "Sass": 148557, "PHP": 51440, "Handlebars": 47094, "Kotlin": 28079, "Python": 25431, "Groovy": 22872, "Ruby": 22085, "ActionScript": 16386, "Shell": 15503, "PowerShell": 13617, "Twig": 3998, "Batchfile": 2368, "Dockerfile": 2322, "EJS": 820, "Makefile": 285, "Harbour": 168, "Mustache": 90} |
/**
*
* EN: Service REST with POST
* EN: Let's call an external REST service with the method
* EN: post and send a JSON.
*
* PT: Serviço REST com POST
* PT: Vamos chamar um serviço REST externo com o método
* PT: post e enviar um JSON.
*
*/
val client = _remote.init()
val response = client.asJSON().post("http://httpbin.org/post", hashMapOf(
"name" to "morpheus",
"job" to "leader"
))
_out.json(response)
| 4 | JavaScript | 3 | 26 | c13fa21dd0fe6b113d8efb63cd453c0ec8cdbb39 | 434 | platform | Apache License 2.0 |
psolib/src/commonTest/kotlin/world/phantasmal/psolib/fileFormats/quest/DatTests.kt | DaanVandenBosch | 189,066,992 | false | null | package world.phantasmal.psolib.fileFormats.quest
import world.phantasmal.psolib.cursor.cursor
import world.phantasmal.psolib.test.LibTestSuite
import world.phantasmal.psolib.test.assertDeepEquals
import world.phantasmal.psolib.test.readFile
import kotlin.test.Test
import kotlin.test.assertEquals
class DatTests : LibTestSuite {
@Test
fun parse_quest_towards_the_future() = testAsync {
val dat = parseDat(readFile("/quest118_e_decompressed.dat"))
assertEquals(277, dat.objs.size)
assertEquals(216, dat.npcs.size)
}
/**
* Parse a file, convert the resulting structure to DAT again and check whether the end result
* is byte-for-byte equal to the original.
*/
@Test
fun parse_dat_and_write_dat() = testAsync {
val origDat = readFile("/quest118_e_decompressed.dat")
val newDat = writeDat(parseDat(origDat)).cursor()
origDat.seekStart(0)
assertDeepEquals(origDat, newDat)
}
/**
* Parse a file, modify the resulting structure, convert it to DAT again and check whether the
* end result is byte-for-byte equal to the original except for the bytes that should be
* changed.
*/
@Test
fun parse_modify_write_dat() = testAsync {
val origDat = readFile("/quest118_e_decompressed.dat")
val parsedDat = parseDat(origDat)
origDat.seekStart(0)
parsedDat.objs[9].data.setFloat(16, 13f)
parsedDat.objs[9].data.setFloat(20, 17f)
parsedDat.objs[9].data.setFloat(24, 19f)
val newDat = writeDat(parsedDat).cursor()
assertEquals(origDat.size, newDat.size)
while (origDat.hasBytesLeft()) {
if (origDat.position == 16 + 9 * OBJECT_BYTE_SIZE + 16) {
origDat.seek(12)
assertEquals(13f, newDat.float())
assertEquals(17f, newDat.float())
assertEquals(19f, newDat.float())
} else {
assertEquals(origDat.byte(), newDat.byte())
}
}
}
}
| 1 | Kotlin | 5 | 20 | 423c3e252b2be6de63a03108915861fced90aaa6 | 2,048 | phantasmal-world | MIT License |
application/api/src/main/kotlin/io/raemian/api/support/JwtFilter.kt | depromeet | 717,344,375 | false | {"Kotlin": 31387} | package io.raemian.api.support
import jakarta.servlet.FilterChain
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import org.springframework.security.core.Authentication
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.util.StringUtils
import org.springframework.web.filter.OncePerRequestFilter
class JwtFilter(
private val tokenProvider: TokenProvider,
) : OncePerRequestFilter() {
private val AUTHORIZATION_HEADER = "Authorization"
private val BEARER_PREFIX = "Bearer "
override fun doFilterInternal(
request: HttpServletRequest,
response: HttpServletResponse,
filterChain: FilterChain,
) {
// 1. Request Header 에서 토큰을 꺼냄
val jwt: String = resolveToken(request)
// 2. validateToken 으로 토큰 유효성 검사
// 정상 토큰이면 해당 토큰으로 Authentication 을 가져와서 SecurityContext 에 저장
if (StringUtils.hasText(jwt) && tokenProvider.validateToken(jwt)) {
val authentication: Authentication = tokenProvider.getAuthentication(jwt)
SecurityContextHolder.getContext().authentication = authentication
}
filterChain.doFilter(request, response)
}
// Request Header 에서 토큰 정보를 꺼내오기
private fun resolveToken(request: HttpServletRequest): String {
val bearerToken = request.getHeader(AUTHORIZATION_HEADER)
return if (StringUtils.hasText(bearerToken) && bearerToken.startsWith(BEARER_PREFIX)) {
bearerToken.split(" ".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()[1].trim { it <= ' ' }
} else {
""
}
}
}
| 9 | Kotlin | 0 | 1 | e7973d2ce47441043eb2aee2a917d77c8c9ccec5 | 1,671 | amazing3-be | Apache License 2.0 |
kool-physics/src/commonMain/kotlin/de/fabmax/kool/physics/TriggerListener.kt | fabmax | 81,503,047 | false | null | package de.fabmax.kool.physics
interface TriggerListener {
fun onActorEntered(trigger: RigidActor, actor: RigidActor) { }
fun onActorExited(trigger: RigidActor, actor: RigidActor) { }
fun onShapeEntered(trigger: RigidActor, actor: RigidActor, shape: Shape) { }
fun onShapeExited(trigger: RigidActor, actor: RigidActor, shape: Shape) { }
} | 3 | Kotlin | 7 | 78 | 2aeb035ab84e4c660bc11f5167a7f485b4a86da8 | 356 | kool | Apache License 2.0 |
implementation/src/test/kotlin/io/github/tomplum/aoc/map/CosmicMapTest.kt | TomPlum | 724,225,748 | false | {"Kotlin": 141244} | package io.github.tomplum.aoc.map
import assertk.assertThat
import assertk.assertions.isEqualTo
import io.github.tomplum.aoc.input.TestInputReader
import org.junit.jupiter.api.Test
class CosmicMapTest {
private val data = TestInputReader.read<String>("day11/example.txt").value
private val cosmicMap = CosmicMap(data)
@Test
fun examplePartOne() {
val distanceSum = cosmicMap.calculateGalacticDistancesAfterExpansion()
assertThat(distanceSum).isEqualTo(374)
}
@Test
fun exampleOnePartTwo() {
val distanceSum = cosmicMap.calculateGalacticDistancesAfterExpansion(
horizontalExpansion = 10,
verticalExpansion = 10
)
assertThat(distanceSum).isEqualTo(1030)
}
@Test
fun exampleTwoPartTwo() {
val distanceSum = cosmicMap.calculateGalacticDistancesAfterExpansion(
horizontalExpansion = 100,
verticalExpansion = 100
)
assertThat(distanceSum).isEqualTo(8410)
}
} | 0 | Kotlin | 0 | 1 | d1f941a3c5bacd126177ace6b9f576c9af07fed6 | 1,013 | advent-of-code-2023 | Apache License 2.0 |
examples/android_kts/my-library/src/main/java/org/jetbrains/my_library/MyComposable.kt | johnryM | 560,115,388 | false | {"Kotlin": 251213} | package org.jetbrains.my_library
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
@Composable
fun MyComposable(name: String, showLongText: Boolean) {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(12.dp)
) {
val text = if (showLongText) {
"Hi $name! How are you doing?"
} else {
"Hi $name"
}
Text(text = text)
}
}
@Preview
@Composable
fun Preview() {
MyComposable(name = "John", showLongText = true)
} | 0 | Kotlin | 0 | 0 | 530186c49c9e6d10ca309c2678ac153394fef685 | 822 | kover-annotation-issue-sample | Apache License 2.0 |
src/testFixtures/kotlin/dev/monosoul/jooq/functional/FunctionalTestBase.kt | monosoul | 497,003,599 | false | null | package dev.monosoul.jooq.functional
import org.gradle.testkit.runner.BuildResult
import org.gradle.testkit.runner.BuildTask
import org.gradle.testkit.runner.GradleRunner
import org.junit.jupiter.api.io.TempDir
import strikt.api.Assertion
import strikt.assertions.isNotNull
import java.io.File
import java.io.FileOutputStream
abstract class FunctionalTestBase {
@TempDir
private lateinit var projectDir: File
protected open fun recreateProjectDir() {
projectDir.deleteRecursively()
projectDir.mkdirs()
}
protected fun runGradleWithArguments(vararg arguments: String): BuildResult =
GradleRunner.create()
.withProjectDir(projectDir)
.withPluginClasspath()
.forwardOutput()
.withArguments(*arguments, "--stacktrace", "--info")
.build()
protected fun copyResource(
from: String,
to: String,
) {
val destinationFile = projectFile(to)
javaClass.getResourceAsStream(from)?.use { sourceStream ->
FileOutputStream(destinationFile).use { destinationStream ->
sourceStream.copyTo(destinationStream)
}
} ?: throw IllegalStateException("Resource not found: $from")
}
protected fun prepareBuildGradleFile(
scriptName: String = "build.gradle.kts",
scriptSupplier: () -> String,
) = writeProjectFile(scriptName, scriptSupplier)
protected fun writeProjectFile(
fileName: String,
bodySupplier: () -> String,
) = projectFile(fileName)
.writeText(bodySupplier())
protected fun projectFile(fileName: String) = File(projectDir, fileName).also { it.parentFile.mkdirs() }
protected fun Assertion.Builder<BuildResult>.getTask(taskName: String) =
get { task(":$taskName") }
.describedAs("Task $taskName")
protected val Assertion.Builder<BuildTask?>.outcome get() = isNotNull().get { outcome }
protected fun Assertion.Builder<BuildResult>.getTaskOutcome(taskName: String) = getTask(taskName).outcome
protected val Assertion.Builder<BuildResult>.generateJooqClassesTask get() = getTask("generateJooqClasses")
}
| 1 | Kotlin | 2 | 9 | f3cc5cbaf77e3a2a22c767fee75de4f809cea477 | 2,188 | jooq-gradle-plugin | Apache License 2.0 |
feature-deep-linking/src/main/java/io/novafoundation/nova/feature_deep_linking/presentation/handling/common/DeepLinkHandlingException.kt | novasamatech | 415,834,480 | false | {"Kotlin": 11121812, "Rust": 25308, "Java": 17664, "JavaScript": 425} | package io.novafoundation.nova.app.root.presentation.deepLinks.common
sealed class DeepLinkHandlingException : Exception() {
sealed class ReferendumHandlingException : DeepLinkHandlingException() {
object ReferendumIsNotSpecified : ReferendumHandlingException()
object ChainIsNotFound : ReferendumHandlingException()
object GovernanceTypeIsNotSpecified : ReferendumHandlingException()
object GovernanceTypeIsNotSupported : ReferendumHandlingException()
}
sealed class DAppHandlingException : DeepLinkHandlingException() {
object UrlIsInvalid : DAppHandlingException()
class DomainIsNotMatched(val domain: String) : DAppHandlingException()
}
sealed class ImportMnemonicHandlingException : DeepLinkHandlingException() {
object InvalidMnemonic : ImportMnemonicHandlingException()
object InvalidCryptoType : ImportMnemonicHandlingException()
object InvalidDerivationPath : ImportMnemonicHandlingException()
}
}
| 12 | Kotlin | 30 | 50 | 127f8739ca86dc74d006f018237daed0de5095a1 | 1,016 | nova-wallet-android | Apache License 2.0 |
mobile/src/main/java/com/siliconlabs/bledemo/home_screen/menu_items/OTADemo.kt | SiliconLabs | 85,345,875 | false | {"Gradle Kotlin DSL": 3, "Java Properties": 2, "Shell": 1, "Text": 3, "Ignore List": 1, "Batchfile": 1, "Git Attributes": 1, "Markdown": 1, "Proguard": 1, "XML": 692, "Kotlin": 415, "HTML": 1, "GLSL": 2} | package com.siliconlabs.bledemo.home_screen.menu_items
import androidx.annotation.DrawableRes
import com.siliconlabs.bledemo.bluetooth.services.BluetoothService
class OTADemo( @DrawableRes imageResId: Int,
title: String,
description: String
) : DemoMenuItem(imageResId, title, description
) {
override val connectType: BluetoothService.GattConnectType = BluetoothService.GattConnectType.WIFI_OTA_UPDATE
} | 20 | Kotlin | 70 | 137 | 5e2be2a37554094ce0cd7043345484b983245290 | 411 | Bluegecko-android | Apache License 2.0 |
pkl/src/main/java/com/polstat/pkl/repository/WilayahRepository.kt | Mjulianfr001056 | 739,524,606 | false | {"Gradle": 33, "Shell": 3, "Markdown": 22, "Java Properties": 6, "Ignore List": 36, "Batchfile": 1, "Git Attributes": 1, "YAML": 3, "XML": 553, "Gradle Kotlin DSL": 9, "Kotlin": 799, "INI": 30, "Java": 723, "Proguard": 3, "JSON": 4, "Text": 2, "JavaScript": 1} | package com.polstat.pkl.repository
import com.polstat.pkl.database.entity.WilayahEntity
import com.polstat.pkl.model.domain.Wilayah
import com.polstat.pkl.utils.Result
import kotlinx.coroutines.flow.Flow
interface WilayahRepository {
suspend fun insertWilayah(wilayah: Wilayah) : Flow<String>
suspend fun updateWilayah(wilayahEntity: WilayahEntity) : Flow<String>
suspend fun updateStatusWilayah(idBS: String, status: String) : Flow<String>
suspend fun getWilayah(idBS: String) : Flow<Result<WilayahEntity>>
suspend fun getAllWilayah(): Flow<Result<List<WilayahEntity>>>
suspend fun deleteAllWilayah() : Flow<String>
suspend fun deleteWilayah(idBS: String) : Flow<String>
} | 0 | Java | 0 | 0 | 654fe234a2fb2c7d578a57036ef6e0fb29e12e20 | 711 | backup-capi2 | Apache License 2.0 |
app/src/main/java/com/inipage/homelylauncher/model/ApplicationIconCheckable.kt | maclyn | 355,712,049 | false | {"Gradle": 3, "Markdown": 2, "Java Properties": 2, "Shell": 1, "Ignore List": 1, "Batchfile": 1, "JSON": 1, "XML": 97, "Kotlin": 30, "Java": 84} | package com.inipage.homelylauncher.model
class ApplicationIconCheckable(appIcon: ApplicationIconHideable) :
ApplicationIcon(appIcon.packageName, appIcon.activityName, appIcon.name)
{
var isChecked: Boolean = false
override fun hashCode(): Int {
return super.hashCode() * if (isChecked) 1 else -1
}
override fun equals(other: Any?): Boolean {
return if (other !is ApplicationIconHideable) {
false
} else other.hashCode() == this.hashCode()
}
override fun toString(): String {
return super.toString() + if (isChecked) " (checked)" else ""
}
} | 0 | Java | 0 | 1 | df64a40519b0bbb396a4585a031322e3514103ce | 621 | curveball-launcher | MIT License |
sdk/src/main/java/com/microsoft/did/sdk/credential/service/Request.kt | TaffyWrinkle | 284,009,182 | true | {"Kotlin": 486107} | /*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
package com.microsoft.did.sdk.credential.service
import com.microsoft.did.sdk.credential.service.models.attestations.CredentialAttestations
import com.microsoft.did.sdk.credential.service.models.attestations.PresentationAttestation
import com.microsoft.did.sdk.credential.service.models.attestations.PresentationRequestBinding
import com.microsoft.did.sdk.credential.service.models.contracts.VerifiableCredentialContract
import com.microsoft.did.sdk.credential.service.models.oidc.OidcRequestContent
import kotlinx.serialization.Serializable
@Serializable
sealed class Request(val attestations: CredentialAttestations?, val entityName: String = "", val entityIdentifier: String = "") {
private var presentationBinding: PresentationRequestBinding? = null
fun getCredentialAttestations(): CredentialAttestations? {
return attestations
}
fun hasPresentationAttestations(): Boolean {
if (attestations?.presentations != null) {
return true
}
return false
}
fun getPresentationAttestations(): List<PresentationAttestation> {
val attestations = attestations?.presentations
if (attestations != null) {
return attestations
}
return emptyList()
}
}
@Serializable
class IssuanceRequest(val contract: VerifiableCredentialContract, val contractUrl: String) :
Request(contract.input.attestations, contract.display.card.issuedBy, contract.input.issuer)
@Serializable
class PresentationRequest(val serializedToken: String, val content: OidcRequestContent) :
Request(content.attestations, content.registration?.clientName ?: "", content.iss) | 0 | null | 0 | 0 | e29bf44879f3177c7ae07018e5d97a61053b1978 | 2,009 | VerifiableCredential-SDK-Android | MIT License |
foryouandme/src/main/java/com/foryouandme/ui/auth/onboarding/OnboardingFragment.kt | 4YouandMeData | 610,425,317 | false | null | package com.foryouandme.ui.auth.onboarding
import android.os.Bundle
import android.view.View
import androidx.fragment.app.viewModels
import androidx.navigation.fragment.NavHostFragment
import com.foryouandme.R
import com.foryouandme.core.arch.flow.observeIn
import com.foryouandme.core.arch.flow.unwrapEvent
import com.foryouandme.core.ext.catchToNull
import com.foryouandme.databinding.OnboardingBinding
import com.foryouandme.ui.auth.AuthSectionFragment
import com.foryouandme.ui.auth.onboarding.step.OnboardingStepFragment
import com.foryouandme.ui.auth.onboarding.step.OnboardingStepNavController
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.flow.onEach
@AndroidEntryPoint
class OnboardingFragment : AuthSectionFragment(R.layout.onboarding) {
private val viewModel: OnboardingViewModel by viewModels()
private val binding: OnboardingBinding?
get() = view?.let { OnboardingBinding.bind(it) }
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
viewModel.loading
.unwrapEvent(name)
.onEach {
when (it.task) {
OnboardingLoading.Initialization,
OnboardingLoading.NextStep ->
binding?.loading?.setVisibility(it.active)
}
}
.observeIn(this)
viewModel.error
.unwrapEvent(name)
.onEach {
when (it.cause) {
OnboardingError.Initialization ->
binding?.error?.setError(it.error, viewModel.state.configuration)
{ viewModel.execute(OnboardingStateEvent.Initialize(authFragment().updateConsentArg())) }
OnboardingError.NextStep ->
binding?.error?.setError(it.error, viewModel.state.configuration)
}
}
.observeIn(this)
viewModel.stateUpdate
.unwrapEvent(name)
.onEach {
when (it) {
is OnboardingStateUpdate.Initialized -> setupNavigation()
}
}
.observeIn(this)
viewModel.navigation
.unwrapEvent(name)
.onEach {
when (it) {
OnboardingToMain ->
navigator.navigateTo(rootNavController(), it)
is OnboardingStepToOnboardingStep ->
navigator.navigateTo(onboardingNavController(), it)
}
}
.observeIn(this)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
if (viewModel.isInitialized().not())
viewModel.execute(OnboardingStateEvent.Initialize(authFragment().updateConsentArg()))
else
setupNavigation()
}
private fun setupNavigation() {
val navHostFragment =
childFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
val currentGraph = catchToNull { navHostFragment.navController.graph }
if (currentGraph == null) {
val inflater = navHostFragment.navController.navInflater
val graph = inflater.inflate(R.navigation.onboarding_navigation)
navHostFragment.navController.graph = graph
}
}
private fun onboardingNavController(): OnboardingStepNavController {
val stepFragment = childFragmentManager.fragments[0]
.childFragmentManager.fragments[0]
.childFragmentManager.fragments[0]
return (stepFragment as OnboardingStepFragment).onboardingStepNavController()
}
} | 0 | Kotlin | 0 | 0 | bc82972689db5052344365ac07c8f6711f5ad7fa | 3,774 | 4YouandMeAndroid | MIT License |
bitapp/src/main/java/com/atech/bit/ui/fragments/library/LibraryFragment.kt | aiyu-ayaan | 489,575,997 | false | null | package com.atech.bit.ui.fragments.library
import android.os.Bundle
import android.view.View
import android.viewbinding.library.fragment.viewBinding
import androidx.core.view.doOnPreDraw
import androidx.core.view.isVisible
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.asLiveData
import androidx.navigation.fragment.FragmentNavigatorExtras
import androidx.navigation.fragment.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import com.atech.bit.R
import com.atech.bit.databinding.FragmentLibraryBinding
import com.atech.core.data.room.library.LibraryModel
import com.atech.core.utils.CalendarReminder
import com.atech.core.utils.showSnackBar
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import com.google.android.material.snackbar.Snackbar
import com.google.android.material.transition.MaterialElevationScale
import com.google.android.material.transition.MaterialSharedAxis
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class LibraryFragment : Fragment(R.layout.fragment_library) {
private val binding: FragmentLibraryBinding by viewBinding()
private val viewModel: LibraryViewModel by viewModels()
private lateinit var libraryAdapter: LibraryAdapter
private var list: List<LibraryModel> = emptyList()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enterTransition = MaterialSharedAxis(MaterialSharedAxis.Y, true)
returnTransition = MaterialSharedAxis(MaterialSharedAxis.Y, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
postponeEnterTransition()
view.doOnPreDraw { startPostponedEnterTransition() }
libraryAdapter = LibraryAdapter(
onDeleteClick = {
deleteBook(it)
},
onMarkAsReturnClick = { lab ->
markAsReturn(lab)
},
) { l, fab ->
navigateToAddEdit(l.bookName, fab, l)
}
binding.apply {
setRecyclerView()
buttonClick()
appBar()
}
getData()
}
private fun FragmentLibraryBinding.appBar() {
bottomAppBar.apply {
setNavigationOnClickListener {
// show dialog for delete all books
MaterialAlertDialogBuilder(requireContext()).setTitle("Delete All Books")
.setMessage("Are you sure you want to delete all books?")
.setPositiveButton("Yes") { _, _ ->
list.forEach {
deleteBook(it)
}
}.setNegativeButton("No", null).show()
}
setOnMenuItemClickListener {
when (it.itemId == R.id.action_info) {
true -> {
binding.root.showSnackBar(
"Data is store locally in your device",
Snackbar.LENGTH_SHORT
)
true
}
false -> false
}
}
}
}
private fun deleteBook(it: LibraryModel) {
if (it.eventId != -1L) {
CalendarReminder.deleteEvent(requireContext(), it.eventId)
}
viewModel.deleteBook(it)
}
private fun markAsReturn(it: LibraryModel) {
val markAsReturn = it.markAsReturn
if (it.eventId != -1L) {
CalendarReminder.deleteEvent(requireContext(), it.eventId)
}
viewModel.updateBook(
it.copy(
eventId = -1L, alertDate = 0L, markAsReturn = !markAsReturn
)
)
}
private fun getData() {
viewModel.libraryList.asLiveData().observe(viewLifecycleOwner) {
binding.emptyAnimation.isVisible = it.isEmpty()
libraryAdapter.submitList(it)
list = it
val layoutManager = binding.recyclerViewLibrary.layoutManager as LinearLayoutManager
layoutManager.scrollToPositionWithOffset(0, 0)
}
}
private fun FragmentLibraryBinding.buttonClick() {
val transitionName = resources.getString(R.string.add_books)
fabAddBook.transitionName = transitionName
fabAddBook.setOnClickListener {
navigateToAddEdit(
transitionName, it
)
}
}
private fun navigateToAddEdit(
string: String, fabAddBook: View, libraryModel: LibraryModel? = null
) {
val extras = FragmentNavigatorExtras(fabAddBook to string)
exitTransition = MaterialElevationScale(false).apply {
duration = resources.getInteger(R.integer.duration_medium).toLong()
}
reenterTransition = MaterialElevationScale(true).apply {
duration = resources.getInteger(R.integer.duration_medium).toLong()
}
val action = LibraryFragmentDirections.actionLibraryFragmentToAddEditFragment(
string, libraryModel
)
findNavController().navigate(action, extras)
}
private fun FragmentLibraryBinding.setRecyclerView() = this.recyclerViewLibrary.apply {
adapter = libraryAdapter
layoutManager = LinearLayoutManager(requireContext())
}
} | 6 | Kotlin | 5 | 13 | 96f082c8e1fb1eb4aa446afce83f98b7494b4884 | 5,445 | BIT-App | MIT License |
ocpp-2-0-core/src/main/kotlin/com/izivia/ocpp/core20/model/remotestart/CostType.kt | IZIVIA | 501,708,979 | false | {"Kotlin": 1934096} | package com.izivia.ocpp.core20.model.remotestart
import com.izivia.ocpp.core20.model.remotestart.enumeration.CostKindEnumType
data class CostType(
val costKind: CostKindEnumType,
val amount: Int,
val amountMultiplier: Int? = null,
) | 6 | Kotlin | 10 | 32 | bd8e7334ae05ea75d02d96a508269acbe076bcd8 | 246 | ocpp-toolkit | MIT License |
rulebook-ktlint/src/main/kotlin/com/hendraanggrian/rulebook/ktlint/ConstructorPositionRule.kt | hendraanggrian | 556,969,715 | false | {"Kotlin": 141601, "Java": 3716, "Groovy": 171} | package com.hendraanggrian.rulebook.ktlint
import com.hendraanggrian.rulebook.ktlint.internals.Messages
import com.hendraanggrian.rulebook.ktlint.internals.contains
import com.pinterest.ktlint.rule.engine.core.api.ElementType.CLASS_BODY
import com.pinterest.ktlint.rule.engine.core.api.ElementType.CLASS_INITIALIZER
import com.pinterest.ktlint.rule.engine.core.api.ElementType.FUN
import com.pinterest.ktlint.rule.engine.core.api.ElementType.PROPERTY
import com.pinterest.ktlint.rule.engine.core.api.ElementType.PROPERTY_ACCESSOR
import com.pinterest.ktlint.rule.engine.core.api.ElementType.SECONDARY_CONSTRUCTOR
import org.jetbrains.kotlin.com.intellij.lang.ASTNode
import org.jetbrains.kotlin.psi.psiUtil.siblings
/**
* [See wiki](https://github.com/hendraanggrian/rulebook/wiki/Rules#constructor-position)
*/
public class ConstructorPositionRule : Rule("constructor-position") {
override fun beforeVisitChildNodes(
node: ASTNode,
autoCorrect: Boolean,
emit: (offset: Int, errorMessage: String, canBeAutoCorrected: Boolean) -> Unit,
) {
// first line of filter
if (node.elementType != CLASS_BODY) {
return
}
// there may be multiple constructors in JVM, target class instead for efficiency
val constructor = node.findChildByType(SECONDARY_CONSTRUCTOR) ?: return
// checks for violation
constructor.siblings(true).filter { it.isPropertyOrInitializer() }
.forEach { emit(it.startOffset, Messages[MSG_PROPERTIES], false) }
constructor.siblings(false).filter { it.isMethod() }
.forEach { emit(it.startOffset, Messages[MSG_METHODS], false) }
}
internal companion object {
const val MSG_PROPERTIES = "constructor.position.properties"
const val MSG_METHODS = "constructor.position.methods"
private fun ASTNode.isPropertyOrInitializer(): Boolean {
if (elementType == PROPERTY) {
return PROPERTY_ACCESSOR !in this
}
return elementType == CLASS_INITIALIZER
}
private fun ASTNode.isMethod(): Boolean {
if (elementType == PROPERTY) {
return PROPERTY_ACCESSOR in this
}
return elementType == FUN
}
}
}
| 0 | Kotlin | 0 | 1 | fde9465da7e53aa46c9c24ed47d6ca78b1d345e2 | 2,296 | rulebook | Apache License 2.0 |
src/main/kotlin/com/linux/createcompilador/service/Utility.kt | FrancoAlv | 636,557,842 | false | null | package com.linux.createcompilador.service
import org.springframework.stereotype.Service
@Service
class Utility{
} | 0 | Kotlin | 0 | 0 | ef7974d7cc50d5599ab747f7b03f21383ac5d5ee | 118 | InstaladorArchLinux | Apache License 2.0 |
feature/home/src/test/kotlin/nl/q42/template/presentation/home/HomeViewModelTest.kt | Q42 | 593,537,486 | false | {"Kotlin": 53124, "Python": 2058, "Ruby": 1169} | package nl.q42.template.presentation.home
import app.cash.turbine.test
import io.mockk.coEvery
import io.mockk.mockk
import junit.framework.TestCase.assertEquals
import junit.framework.TestCase.assertTrue
import kotlinx.coroutines.delay
import kotlinx.coroutines.test.runTest
import nl.q42.template.actionresult.domain.ActionResult
import nl.q42.template.domain.user.model.User
import nl.q42.template.domain.user.usecase.GetUserUseCase
import nl.q42.template.ui.presentation.ViewStateString
import org.junit.Rule
import org.junit.Test
import kotlin.time.Duration.Companion.seconds
class HomeViewModelTest() {
@get:Rule
val mainDispatcherRule = MainDispatcherRule()
@Test
fun `WHEN I subscribe to uiState with a slow UserUseCase THEN I get the loading state and expected email address`() = runTest {
val getUserUseCaseMock: GetUserUseCase = mockk()
coEvery { getUserUseCaseMock.invoke() }.coAnswers {
// demonstration of test scheduler. This does not actually block the test for 4 seconds
delay(4.seconds)
ActionResult.Success(User("<EMAIL>"))
}
val viewModel = HomeViewModel(getUserUseCaseMock, mockk())
viewModel.uiState.test {
assertEquals(HomeViewState.Loading, awaitItem())
val viewState = awaitItem()
assertTrue(viewState is HomeViewState.Data)
assertTrue((viewState as HomeViewState.Data).userEmailTitle is ViewStateString.Res)
}
}
@Test
fun `WHEN I subscribe to uiState with a fast UserUseCase THEN I get expected email address immediately`() = runTest {
val getUserUseCaseMock: GetUserUseCase = mockk()
coEvery { getUserUseCaseMock.invoke() }.returns(
ActionResult.Success(
User("<EMAIL>")
)
)
val viewModel = HomeViewModel(getUserUseCaseMock, mockk())
viewModel.uiState.test {
val viewState = awaitItem()
assertTrue(viewState is HomeViewState.Data)
assertTrue((viewState as HomeViewState.Data).userEmailTitle is ViewStateString.Res)
}
}
}
| 6 | Kotlin | 0 | 7 | 44e0668481348816c279159198a0a1ac7b81844a | 2,145 | Template.Android | MIT License |
app/src/wallet/java/com/merative/healthpass/ui/region/RegionSelectionVM.kt | digitalhealthpass | 563,978,682 | false | {"Kotlin": 1047923, "HTML": 79495, "Python": 22113, "Java": 1959} | package com.merative.healthpass.ui.region
import com.merative.healthpass.models.region.Env
import com.merative.healthpass.ui.common.BaseViewModel
import com.merative.healthpass.utils.pref.ContactDB
import com.merative.healthpass.utils.pref.PackageDB
import com.merative.healthpass.utils.pref.IssuerMetadataDB
import com.merative.healthpass.utils.pref.SchemaDB
import io.reactivex.rxjava3.core.Completable
import javax.inject.Inject
class RegionSelectionVM @Inject constructor(
private val environmentHandler: EnvironmentHandler,
private val contactDB: ContactDB,
private val packageDB: PackageDB,
private val issuerMetadataDB: IssuerMetadataDB,
private val schemaDB: SchemaDB,
) : BaseViewModel() {
var currentEnv: Env? = null
init {
currentEnv = environmentHandler.currentEnv
}
fun getRegionList(): List<Env> = environmentHandler.envList
fun saveRegion(): Completable {
return if (currentEnv == null) {
Completable.complete()
} else {
Completable.fromCallable { environmentHandler.putEnvironment(currentEnv!!) }
.andThen(contactDB.deleteAll())
.andThen(packageDB.deleteAll())
.andThen(issuerMetadataDB.deleteAll())
.andThen(schemaDB.deleteAll())
}
}
} | 0 | Kotlin | 0 | 0 | 2b086f6fad007d1a574f8f0511fff0e65e100930 | 1,321 | dhp-android-app | Apache License 2.0 |
app/src/androidTest/java/com/axel_stein/glucose_tracker/view_model/StatisticsViewModelTest.kt | AxelStein | 320,277,698 | false | null | package com.axel_stein.glucose_tracker.view_model
import android.arch.core.executor.testing.InstantTaskExecutorRule
import androidx.room.Room
import androidx.test.platform.app.InstrumentationRegistry
import com.axel_stein.glucose_tracker.RxImmediateSchedulerRule
import com.axel_stein.glucose_tracker.data.room.AppDatabase
import com.axel_stein.glucose_tracker.data.room.dao.A1cLogDao
import com.axel_stein.glucose_tracker.data.room.dao.GlucoseLogDao
import com.axel_stein.glucose_tracker.data.room.dao.StatsDao
import com.axel_stein.glucose_tracker.data.settings.AppResources
import com.axel_stein.glucose_tracker.data.settings.AppSettings
import org.junit.After
import org.junit.Before
import org.junit.Rule
class StatisticsViewModelTest {
@JvmField
@Rule
val instantTaskExecutorRule = InstantTaskExecutorRule()
@Rule
@JvmField
var testSchedulerRule = RxImmediateSchedulerRule()
private lateinit var db: AppDatabase
private lateinit var dao: StatsDao
private lateinit var glucoseDao: GlucoseLogDao
private lateinit var a1cDao: A1cLogDao
private lateinit var appSettings: AppSettings
private lateinit var appResources: AppResources
@Before
fun setUp() {
val context = InstrumentationRegistry.getInstrumentation().targetContext
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java).build()
dao = db.statsDao()
glucoseDao = db.glucoseLogDao()
a1cDao = db.a1cDao()
appSettings = AppSettings(context)
appResources = AppResources(context, db.glucoseMeasuredDao())
}
@After
fun closeDb() {
glucoseDao.deleteAll()
db.close()
}
/*@Test
fun testNoData() {
val vm = StatisticsViewModel(dao, glucoseDao, a1cDao, appSettings, appResources)
assertNull(vm.statsLiveData().value)
assertNull(vm.diabetesControlLiveData().value)
assertFalse(vm.showErrorLiveData().value ?: true)
}
@Test
fun testControlGood() {
glucoseDao.insert(createLog(4f))
val vm = StatisticsViewModel(dao, glucoseDao, a1cDao, appSettings, appResources)
assertNotNull(vm.statsLiveData().value)
assertNotNull(vm.diabetesControlLiveData().value)
assertEquals(0, vm.diabetesControlLiveData().value)
assertFalse(vm.showErrorLiveData().value ?: true)
}
@Test
fun testControlAvg() {
glucoseDao.insert(createLog(8f))
val vm = StatisticsViewModel(dao, glucoseDao, a1cDao, appSettings, appResources)
assertNotNull(vm.statsLiveData().value)
assertNotNull(vm.diabetesControlLiveData().value)
assertFalse(vm.showErrorLiveData().value ?: true)
}
@Test
fun testControlBad() {
glucoseDao.insert(createLog(10f))
val vm = StatisticsViewModel(dao, glucoseDao, a1cDao, appSettings, appResources)
assertNotNull(vm.statsLiveData().value)
assertNotNull(vm.diabetesControlLiveData().value)
assertFalse(vm.showErrorLiveData().value ?: true)
}
private fun createLog(mmol: Float = 4f): GlucoseLog {
return GlucoseLog(mmol, 90, 0, DateTime(), "")
}
*/
} | 4 | Kotlin | 0 | 1 | 960fe9268fb04663de836c6ce9f5500f7179cabf | 3,183 | GlucoseTracker | Apache License 2.0 |
module/src/main/java/me/eugeniomarletti/sample/SampleAnnotation.kt | Takhion | 81,495,988 | false | null | package me.eugeniomarletti.sample
import kotlin.annotation.AnnotationTarget.CLASS
@Target(CLASS)
annotation class SampleAnnotation
| 0 | Kotlin | 4 | 25 | 16bf85699f067effc97f5f183356eba29fa2cda9 | 134 | generate-kotlin-multiple-rounds | MIT License |
src/main/kotlin/no/nav/amt/distribusjon/digitalbruker/api/DigitalBrukerApi.kt | navikt | 775,942,443 | false | {"Kotlin": 229276, "PLpgSQL": 635, "Dockerfile": 194} | package no.nav.amt.distribusjon.digitalbruker.api
import io.ktor.server.auth.authenticate
import io.ktor.server.request.receive
import io.ktor.server.response.respond
import io.ktor.server.routing.Routing
import io.ktor.server.routing.post
import no.nav.amt.distribusjon.digitalbruker.DigitalBrukerService
fun Routing.registerDigitalBrukerApi(digitalBrukerService: DigitalBrukerService) {
authenticate("SYSTEM") {
post("/digital") {
val request = call.receive<DigitalBrukerRequest>()
call.respond(DigitalBrukerResponse(digitalBrukerService.erDigital(request.personident)))
}
}
}
data class DigitalBrukerRequest(
val personident: String,
)
data class DigitalBrukerResponse(
val erDigital: Boolean,
)
| 0 | Kotlin | 0 | 0 | 154d91cdf5b8eb00192de15182fe461736ae8c4c | 759 | amt-distribusjon | MIT License |
app/src/main/java/com/jsevilla/musicapp/presentation/feature/search/SearchView.kt | sevilla1jose | 279,116,233 | false | null | package com.jsevilla.musicapp.presentation.feature.search
import com.jsevilla.musicapp.domain.entity.Music
import com.jsevilla.musicapp.presentation.base.View
interface SearchView : View {
fun showLoading()
fun hideLoading()
fun success(list: List<Music>)
fun empty()
fun connection()
} | 0 | Kotlin | 0 | 0 | 6f9a90ba7a31de87a5da4dbfcca9a7586cd7c1eb | 312 | music-app | Apache License 2.0 |
src/androidx/compose/animation/AnimateContentSingleSizeDimension.kt | zhelenskiy | 760,712,556 | false | {"Kotlin": 8058} | package androidx.compose.animation
import androidx.compose.animation.core.Animatable
import androidx.compose.animation.core.AnimationEndReason
import androidx.compose.animation.core.AnimationSpec
import androidx.compose.animation.core.AnimationVector1D
import androidx.compose.animation.core.FiniteAnimationSpec
import androidx.compose.animation.core.VectorConverter
import androidx.compose.animation.core.spring
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import androidx.compose.ui.composed
import androidx.compose.ui.draw.clipToBounds
import androidx.compose.ui.layout.IntrinsicMeasurable
import androidx.compose.ui.layout.IntrinsicMeasureScope
import androidx.compose.ui.layout.LayoutModifier
import androidx.compose.ui.layout.Measurable
import androidx.compose.ui.layout.MeasureResult
import androidx.compose.ui.layout.MeasureScope
import androidx.compose.ui.platform.debugInspectorInfo
import androidx.compose.ui.unit.Constraints
import androidx.compose.ui.unit.IntSize
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
// copied from androidx.compose.animation.animateContentSize and slightly modified
/**
* This modifier animates its own height when its child modifier (or the child composable if it
* is already at the tail of the chain) changes height. This allows the parent modifier to observe
* a smooth height change, resulting in an overall continuous visual change.
*
* A [FiniteAnimationSpec] can be optionally specified for the height change animation. By default,
* [spring] will be used.
*
* An optional [finishedListener] can be supplied to get notified when the height change animation is
* finished. Since the content height change can be dynamic in many cases, both initial value and
* target value (i.e. final height) will be passed to the [finishedListener]. __Note:__ if the
* animation is interrupted, the initial value will be the height at the point of interruption. This
* is intended to help determine the direction of the height change (i.e. expand or collapse in x and
* y dimensions).
*
* @param animationSpec a finite animation that will be used to animate height change, [spring] by
* default
* @param finishedListener an optional listener to be called when the content change animation is
* completed.
*/
fun Modifier.animateContentHeight(
animationSpec: FiniteAnimationSpec<Int> = spring(),
finishedListener: ((initialValue: Int, targetValue: Int) -> Unit)? = null
): Modifier = composed(
inspectorInfo = debugInspectorInfo {
name = "animateContentHeight"
properties["animationSpec"] = animationSpec
properties["finishedListener"] = finishedListener
}
) {
// TODO: Listener could be a fun interface after 1.4
val scope = rememberCoroutineScope()
val animModifier = remember(scope) {
IntAnimationModifier(animationSpec, scope, AnimationDimension.Height)
}
animModifier.listener = finishedListener
this.clipToBounds().then(animModifier)
}
/**
* This modifier animates its own width when its child modifier (or the child composable if it
* is already at the tail of the chain) changes width. This allows the parent modifier to observe
* a smooth width change, resulting in an overall continuous visual change.
*
* A [FiniteAnimationSpec] can be optionally specified for the width change animation. By default,
* [spring] will be used.
*
* An optional [finishedListener] can be supplied to get notified when the width change animation is
* finished. Since the content width change can be dynamic in many cases, both initial value and
* target value (i.e. final s=width) will be passed to the [finishedListener]. __Note:__ if the
* animation is interrupted, the initial value will be the width at the point of interruption. This
* is intended to help determine the direction of the width change (i.e. expand or collapse in x and
* y dimensions).
*
* @param animationSpec a finite animation that will be used to animate width change, [spring] by
* default
* @param finishedListener an optional listener to be called when the content change animation is
* completed.
*/
fun Modifier.animateContentWidth(
animationSpec: FiniteAnimationSpec<Int> = spring(),
finishedListener: ((initialValue: Int, targetValue: Int) -> Unit)? = null
): Modifier = composed(
inspectorInfo = debugInspectorInfo {
name = "animateContentWidth"
properties["animationSpec"] = animationSpec
properties["finishedListener"] = finishedListener
}
) {
// TODO: Listener could be a fun interface after 1.4
val scope = rememberCoroutineScope()
val animModifier = remember(scope) {
IntAnimationModifier(animationSpec, scope, AnimationDimension.Width)
}
animModifier.listener = finishedListener
this.clipToBounds().then(animModifier)
}
private enum class AnimationDimension {
Width, Height
}
/**
* This class creates a [LayoutModifier] that measures children, and responds to children's size dimension
* change by animating to that size dimension. The size dimension reported to parents will be the animated size dimension.
*/
private class IntAnimationModifier(
val animSpec: AnimationSpec<Int>,
val scope: CoroutineScope,
private val animationDirection: AnimationDimension,
) : PrivateLayoutModifierWithPassThroughIntrinsics() {
var listener: ((startSizeDimension: Int, endSizeDimension: Int) -> Unit)? = null
data class AnimData(
val anim: Animatable<Int, AnimationVector1D>,
var startSizeDimension: Int
)
var animData: AnimData? by mutableStateOf(null)
override fun MeasureScope.measure(
measurable: Measurable,
constraints: Constraints
): MeasureResult {
val placeable = measurable.measure(constraints)
val measuredSize = IntSize(placeable.width, placeable.height)
val (width, height) = when (animationDirection) {
AnimationDimension.Width -> animateTo(measuredSize.width) to measuredSize.height
AnimationDimension.Height -> measuredSize.width to animateTo(measuredSize.height)
}
return layout(width, height) {
placeable.placeRelative(0, 0)
}
}
fun animateTo(targetSizeDimension: Int): Int {
val data = animData?.apply {
if (targetSizeDimension != anim.targetValue) {
startSizeDimension = anim.value
scope.launch {
val result = anim.animateTo(targetSizeDimension, animSpec)
if (result.endReason == AnimationEndReason.Finished) {
listener?.invoke(startSizeDimension, result.endState.value)
}
}
}
} ?: AnimData(
Animatable(
targetSizeDimension, Int.VectorConverter, 1
),
targetSizeDimension
)
animData = data
return data.anim.value
}
}
private abstract class PrivateLayoutModifierWithPassThroughIntrinsics : LayoutModifier {
final override fun IntrinsicMeasureScope.minIntrinsicWidth(
measurable: IntrinsicMeasurable,
height: Int
) = measurable.minIntrinsicWidth(height)
final override fun IntrinsicMeasureScope.minIntrinsicHeight(
measurable: IntrinsicMeasurable,
width: Int
) = measurable.minIntrinsicHeight(width)
final override fun IntrinsicMeasureScope.maxIntrinsicWidth(
measurable: IntrinsicMeasurable,
height: Int
) = measurable.maxIntrinsicWidth(height)
final override fun IntrinsicMeasureScope.maxIntrinsicHeight(
measurable: IntrinsicMeasurable,
width: Int
) = measurable.maxIntrinsicHeight(width)
}
| 0 | Kotlin | 0 | 0 | 40b81d091f6175d063367e0cce343591dc357489 | 8,058 | AnimateContentSingleDimension | MIT License |
Hogwarts/Hogwarts/app/src/main/java/com/bigaton/hogwarts/di/DataSourceModule.kt | brunobigaton | 463,618,141 | false | null | package com.bigaton.hogwarts.di
import com.bigaton.hogwarts.data.remote.RemoteDataSource
import com.bigaton.hogwarts.data.remote.RemoteDataSourceImpl
import org.koin.dsl.module
val dataSourceModule = module {
single<RemoteDataSource> { RemoteDataSourceImpl(service = get()) }
} | 0 | Kotlin | 0 | 0 | d1d746112bc8e25c1ebb203b82c12130dcb3d8f3 | 283 | Potter | MIT License |
core/ui/theme/api/src/main/kotlin/app/k9mail/core/ui/theme/api/Theme.kt | thunderbird | 1,326,671 | false | {"Kotlin": 4766001, "Java": 2159946, "Shell": 2768, "AIDL": 1946} | package app.k9mail.core.ui.theme.api
enum class Theme {
LIGHT,
DARK,
}
| 846 | Kotlin | 2467 | 9,969 | 8b3932098cfa53372d8a8ae364bd8623822bd74c | 80 | thunderbird-android | Apache License 2.0 |
src/main/kotlin/com/creativeparser/exp4k/operator/OperatorUnit.kt | rcadete | 226,582,070 | false | null | package com.creativeparser.exp4k.operator
enum class OperatorUnit(val index: Int, val precedence: Int) {
ADDITION(0,100),
SUBTRACTION(1,ADDITION.precedence),
MULTIPLICATION(2,200),
DIVISION(3,MULTIPLICATION.precedence),
MODULO(4,DIVISION.precedence),
POWER(5,300),
UNARY_MINUS(6,400),
UNARY_PLUS(7,UNARY_MINUS.precedence)
}
| 0 | Kotlin | 0 | 0 | b8b508ba84c7a45bac0f74db0b52632a783406b2 | 358 | exp4k | Apache License 2.0 |
entity/src/main/kotlin/br/com/breiv/payment/PaymentProcessResponse.kt | lucasgust | 189,171,262 | false | null | package br.com.breiv.payment
sealed class PaymentProcessResponse {
abstract val status: PaymentStatusType
data class BankSlipPaymentProcessResponse(
override val status: PaymentStatusType,
val number: String
) : PaymentProcessResponse()
data class CreditCardPaymentProcessResponse(
override val status: PaymentStatusType
) : PaymentProcessResponse()
} | 0 | Kotlin | 0 | 0 | b8582457211c81cece5d79299d611778c3840b00 | 399 | breiv | MIT License |
app/src/main/java/ru/vitaliy/belyaev/wishapp/utils/BytesSizeFormatter.kt | VitaliyBelyaev | 398,851,175 | false | {"Kotlin": 386804, "Swift": 91562, "Ruby": 2345} | package ru.vitaliy.belyaev.wishapp.utils
import java.math.RoundingMode
import java.text.DecimalFormat
import java.text.DecimalFormatSymbols
import java.util.Locale
object BytesSizeFormatter {
private const val KILO_BYTE = 1000.0
private const val MEGA_BYTE = 1000.0 * KILO_BYTE
private const val GIGA_BYTE = 1000.0 * MEGA_BYTE
private val decimalFormat = DecimalFormat(
"#.#",
DecimalFormatSymbols(Locale.ENGLISH)
).apply {
roundingMode = RoundingMode.HALF_EVEN
}
fun format(bytes: Long): String {
return when {
bytes < KILO_BYTE -> "$bytes B"
bytes < MEGA_BYTE -> "${bytesDividedByAndRounded(bytes, KILO_BYTE)} KB"
bytes < GIGA_BYTE -> "${bytesDividedByAndRounded(bytes, MEGA_BYTE)} MB"
else -> "${bytesDividedByAndRounded(bytes, GIGA_BYTE)} GB"
}
}
private fun bytesDividedByAndRounded(
bytes: Long,
divider: Double
): Double {
val rawNumber = bytes / divider
return decimalFormat.format(rawNumber).toDouble()
}
} | 1 | Kotlin | 1 | 23 | f034eebfd9adaea16f723b3aeb0825b946beea96 | 1,085 | WishApp | Apache License 2.0 |
app/src/main/java/com/trycarriage/test/ui/base/ui/BaseActivity.kt | a-najar | 161,784,067 | false | {"Kotlin": 32742} | package com.trycarriage.test.ui.base.ui
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import com.trycarriage.test.application.helpers.ktx.getLayoutRes
import com.trycarriage.test.application.helpers.network.isNetworkConnected
import com.trycarriage.test.ui.base.arch.MvvmNavigator
import com.trycarriage.test.ui.dialogs.connectivity.ConnectivityDialog
import kotlinx.android.synthetic.main.layout_toolbar.*
/**
* @name Test
* Copyrights (c) 12/12/18 Created By <NAME>
**/
open class BaseActivity : AppCompatActivity(), MvvmNavigator {
val connectivityDialog = ConnectivityDialog.newInstance()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// set content view for of the layout by call it from the annotation
setContentView(getLayoutRes().layout)
// init toolbar
initToolBar()
// bind views
bindViews(savedInstanceState)
}
private fun initToolBar() {
toolbar?.let { toolbar ->
setSupportActionBar(toolbar)
// add the back stack if exist
supportActionBar?.let { it.setDisplayHomeAsUpEnabled(getLayoutRes().withBack) }
}
}
open fun bindViews(savedInstanceState: Bundle?) {
}
override fun showLoading() {
}
override fun showError(message: String) {
}
override fun showError(message: Int) {
showError(getString(message))
}
override fun showMessage(message: String) {
}
override fun showMessage(message: Int) {
showMessage(getString(message))
}
override fun isConnected(): Boolean {
return isNetworkConnected()
}
override fun showNoInternetConnection() {
if (!connectivityDialog.isDialogAddedToScreen) {
connectivityDialog.show(supportFragmentManager, ConnectivityDialog.TAG)
}
}
} | 0 | Kotlin | 0 | 0 | 7033775c517af742e748e31b01317edd507d3e23 | 1,908 | repos | Apache License 2.0 |
app/src/main/java/openfoodfacts/github/scrachx/openfood/models/entities/EntityResponse.kt | openfoodfacts | 35,174,991 | false | null | package openfoodfacts.github.scrachx.openfood.models.entities
interface EntityResponse<T> {
fun map(): T
}
| 390 | null | 447 | 772 | 836bab540ec9e2792b692a3b25ff61e444fae045 | 112 | openfoodfacts-androidapp | Apache License 2.0 |
app/src/main/java/com/android/squadster/screenslogic/profile/ProfileView.kt | squadster | 295,106,040 | false | null | package com.android.squadster.screenslogic.profile
import moxy.MvpView
import moxy.viewstate.strategy.alias.AddToEnd
interface ProfileView : MvpView {
} | 0 | Kotlin | 0 | 0 | bf713ec133e79c46a6ad77020751536a0afddf00 | 155 | squadster-android | MIT License |
app/src/main/java/com/samourai/sentinel/ui/dojo/DojoUtil.kt | wanderingking072 | 851,747,619 | false | {"Kotlin": 678939, "Java": 428427} | package com.samourai.sentinel.ui.dojo
import com.samourai.sentinel.api.ApiService
import com.samourai.sentinel.data.db.SentinelCollectionStore
import com.samourai.sentinel.data.db.PayloadRecord
import com.samourai.sentinel.helpers.fromJSON
import com.samourai.sentinel.helpers.toJSON
import com.samourai.sentinel.ui.utils.PrefsUtil
import kotlinx.coroutines.*
import okhttp3.Response
import org.json.JSONObject
import org.koin.java.KoinJavaComponent.inject
import timber.log.Timber
/**
* sentinel-android
*
**/
class DojoUtility {
private var dojoPayload: DojoPairing? = null
private var apiKey: String? = null
private var isAuthenticated = false;
private val prefsUtil: PrefsUtil by inject(PrefsUtil::class.java)
private val dbHandler: SentinelCollectionStore by inject(SentinelCollectionStore::class.java)
private val apiService: ApiService by inject(ApiService::class.java)
private var dojoStore: PayloadRecord
init {
dojoStore = dbHandler.getDojoStore()
read()
}
suspend fun setDojo(pairing: String): Response {
val payload = fromJSON<DojoPairing>(pairing)
?: throw Exception("Invalid payload")
this.dojoPayload = payload
prefsUtil.apiEndPoint = this.dojoPayload!!.pairing?.url
prefsUtil.apiEndPointTor = this.dojoPayload!!.pairing?.url
writePayload(dojoPayload!!);
return apiService.authenticateDojo(dojoPayload!!.pairing!!.apikey!!);
}
fun validate(payloadString: String): Boolean {
try {
val payload = fromJSON<DojoPairing>(payloadString)
?: throw Exception("Invalid payload")
if (payload.pairing == null) {
return false
}
if (payload.pairing.type != "dojo.api") {
return false
}
if (payload.pairing.apikey == null) {
return false
}
if (payload.pairing.url == null) {
return false
}
return true
} catch (ex: Exception) {
return false
}
}
fun isAuthenticated(): Boolean {
return isAuthenticated;
}
fun isDojoEnabled(): Boolean {
return dojoPayload != null
}
suspend fun writePayload(dojoPairing: DojoPairing) = withContext(Dispatchers.IO) {
dbHandler.getDojoStore().write(dojoPairing, true)
}
private fun readPayload(): DojoPairing? {
return if (dojoStore.file.exists()) {
Timber.d("${dbHandler.getDojoStore().read<DojoPairing>()}")
return dbHandler.getDojoStore().read<DojoPairing>()
} else {
null
}
}
fun clearDojo() {
CoroutineScope(Dispatchers.IO).launch {
if (dojoStore.file.exists())
dojoStore.file.delete()
}
dojoPayload = null
prefsUtil.apiEndPointTor = null
prefsUtil.apiEndPoint = null
}
fun setAuthToken(body: String) {
val payload = JSONObject(body).getJSONObject("authorizations")
val authorization = payload.getString("access_token")
val refreshToken = payload.getString("refresh_token")
prefsUtil.authorization = authorization
prefsUtil.refreshToken = refreshToken
isAuthenticated = true
}
fun getApiKey(): String? {
return apiKey;
}
fun read() {
CoroutineScope(Dispatchers.Default).launch {
dojoPayload = readPayload()
if (dojoPayload != null) {
prefsUtil.apiEndPointTor = dojoPayload?.pairing?.url
prefsUtil.apiEndPoint = dojoPayload?.pairing?.url
apiKey = dojoPayload?.pairing?.apikey
apiService.setAccessToken(prefsUtil.refreshToken)
}
}
}
fun store() {
CoroutineScope(Dispatchers.Default).launch {
dojoPayload?.let { writePayload(it) }
}
}
fun exportDojoPayload(): String? {
return dojoPayload?.toJSON()
}
fun setDojoPayload(payloadString: String) {
val payload = fromJSON<DojoPairing>(payloadString)
?: throw Exception("Invalid payload")
this.dojoPayload = payload
}
fun import(dojoPairing: JSONObject) {
dojoPayload = fromJSON(dojoPairing.toString())
}
}
| 0 | Kotlin | 0 | 1 | 00bd0896f8e4b99c91d7dc9bc90d92d95ff6d76e | 4,374 | sentinel-android | The Unlicense |
src/main/kotlin/com/blitzoffline/alphamusic/track/TrackLoader.kt | BlitzOffline | 434,279,924 | false | {"Kotlin": 122890} | package com.blitzoffline.alphamusic.track
import com.blitzoffline.alphamusic.handler.TrackLoaderResultHandler
import com.blitzoffline.alphamusic.manager.GuildManager
import com.google.common.cache.Cache
import com.google.common.cache.CacheBuilder
import com.sedmelluq.discord.lavaplayer.track.AudioItem
import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist
import com.sedmelluq.discord.lavaplayer.track.AudioTrack
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import java.util.concurrent.TimeUnit
/**
* This class is responsible for loading tracks and playlists from various sources. It contains a cache for loaded
* items to avoid loading the same item multiple times. The cache also automatically removes items that haven't been
* used in a while.
*/
class TrackLoader {
val audioItemCache: Cache<String, AudioItem> = CacheBuilder
.newBuilder()
.maximumSize(100)
.expireAfterWrite(25, TimeUnit.MINUTES)
.build()
fun loadTrack(identifier: String, guildManager: GuildManager, event: SlashCommandInteractionEvent?, deferred: Boolean = false) {
val isUrl = URL_REGEX.matches(identifier)
val trackUrl = when {
isUrl -> identifier
else -> "ytsearch:${identifier}"
}
val resultHandler = TrackLoaderResultHandler(event, guildManager, this, trackUrl, guildManager.jda, guildManager.guildHolder.radio(guildManager.guildId), deferred)
val track = audioItemCache.getIfPresent(trackUrl)
?: run {
guildManager.audioPlayerManager.loadItemOrdered(guildManager.audioPlayer, trackUrl, resultHandler)
return
}
when (track) {
is AudioTrack -> {
resultHandler.trackLoaded(track)
}
is AudioPlaylist -> {
resultHandler.playlistLoaded(track)
}
}
}
companion object {
private val URL_REGEX = "^(https?)://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]".toRegex()
}
} | 7 | Kotlin | 0 | 0 | 84dbaceb761a9749eaff58d5cffcd3664eaf0dd4 | 2,078 | AlphaMusic | MIT License |
src/main/kotlin/org/consoletrader/wallet/BalanceTasks.kt | tomaszbabiuk | 116,781,000 | false | null | package org.consoletrader.wallet
import io.reactivex.Single
import org.consoletrader.common.DataSourceTask
import org.consoletrader.common.ExchangeManager
abstract class BalanceTask(val exchangeManager: ExchangeManager) : DataSourceTask<PortfolioAsset, CurrencyAndValueExtendedParams>() {
override fun createDataSource(params: CurrencyAndValueExtendedParams): Single<PortfolioAsset> {
return ListAssetsDataSource(exchangeManager).create()
.toObservable()
.flatMapIterable { it }
.filter {
it.assetSymbol == params.currency.symbol
}
.firstOrError()
}
override fun createParams(paramsRaw: String): CurrencyAndValueExtendedParams {
return CurrencyAndValueExtendedParams(paramsRaw)
}
}
class BalanceAboveTask(exchangeManager: ExchangeManager) : BalanceTask(exchangeManager) {
override fun match(paramsRaw: String): Boolean {
return paramsRaw.startsWith("balanceabove")
}
override fun verifySuccess(data: PortfolioAsset, params: CurrencyAndValueExtendedParams): Boolean {
return data.amount > params.value
}
}
class BalanceBelowTask(exchangeManager: ExchangeManager) : BalanceTask(exchangeManager) {
override fun match(paramsRaw: String): Boolean {
return paramsRaw.startsWith("balancebelow")
}
override fun verifySuccess(data: PortfolioAsset, params: CurrencyAndValueExtendedParams): Boolean {
return data.amount < params.value
}
} | 1 | Kotlin | 2 | 2 | 9c356b4d4bef556ff6fa86ef3aeaae76689e5178 | 1,531 | console-trader | MIT License |
devtools/common/src/commonMain/kotlin/com/maximbircu/devtools/common/presentation/tools/enum/EnumToolPresenter.kt | maximbircu | 247,318,697 | false | null | package com.maximbircu.devtools.common.presentation.tools.enum
import com.maximbircu.devtools.common.core.mvp.BasePresenter
import com.maximbircu.devtools.common.core.mvp.Presenter
/**
* Encapsulates the [EnumTool] business logic and displays enum tool data through [EnumToolView].
*/
interface EnumToolPresenter : Presenter {
/**
* Should be called as soon as a [EnumTool] instance has been provided to the [EnumToolView].
*
* @param tool the tool instance provided to the view
*/
fun onToolBind(tool: EnumTool)
/**
* Should be called whenever the enum tool gets selected.
*/
fun onToolClick()
/**
* Should be invoked whenever the option selector dialog closes by a configuration button click.
*/
fun onPositiveButtonClick()
/**
* Should be invoked whenever the option selector dialog closes by a cancel button click.
*/
fun onNegativeButtonClick()
companion object {
/**
* Provides a new [EnumToolPresenter] instance.
*
* @param view a [EnumToolView] instance
*/
fun create(view: EnumToolView): EnumToolPresenter = EnumToolPresenterImpl(view)
}
}
/**
* A compact enum tool option selector should be presented as soon as the options list size is
* smaller than [MAX_ALLOWED_OPTIONS_FOR_COMPACT_MODE] and a dialog selector vice-versa.
*/
private const val MAX_ALLOWED_OPTIONS_FOR_COMPACT_MODE = 7
private class EnumToolPresenterImpl(
view: EnumToolView
) : BasePresenter<EnumToolView>(view), EnumToolPresenter {
private lateinit var tool: EnumTool
private val isCompactMode get() = tool.options.size < MAX_ALLOWED_OPTIONS_FOR_COMPACT_MODE
private lateinit var dialogSelectedValue: String
override fun onToolBind(tool: EnumTool) {
this.tool = tool
this.dialogSelectedValue = tool.value
if (isCompactMode) {
view.showCompactOptionsSelector(tool) { tool.value = it }
} else {
view.showConfigurationValue(tool.value)
}
}
override fun onToolClick() {
if (!isCompactMode) {
view.showOptionSelectorDialog(tool) { dialogSelectedValue = it }
}
}
override fun onPositiveButtonClick() {
tool.value = dialogSelectedValue
view.showConfigurationValue(dialogSelectedValue)
}
override fun onNegativeButtonClick() {
dialogSelectedValue = tool.value
}
}
| 9 | Kotlin | 1 | 15 | 35205810c5f1af02dbbb9cb9b610f29e58ee99d1 | 2,459 | devtools-library | Apache License 2.0 |
domain/src/main/kotlin/io/petros/prices/domain/repository/instrument/InstrumentsRepository.kt | ParaskP7 | 150,170,958 | false | null | package io.petros.prices.domain.repository.instrument
import io.petros.prices.domain.model.instrument.Instrument
import io.reactivex.Observable
interface InstrumentsRepository {
fun getInstrumentsSubscription(): Observable<Instrument>
fun push(message: String)
}
| 0 | Kotlin | 0 | 3 | dbe3acde562c181fb82fabd014b9e4a4ba405c92 | 276 | sample-code-prices | Apache License 2.0 |
px-checkout/src/main/java/com/mercadopago/android/px/internal/util/CVVRecoveryWrapper.kt | mercadopago | 49,529,486 | false | null | package com.mercadopago.android.px.internal.util
import com.mercadopago.android.px.addons.ESCManagerBehaviour
import com.mercadopago.android.px.internal.extensions.isNotNullNorEmpty
import com.mercadopago.android.px.internal.repository.CardTokenRepository
import com.mercadopago.android.px.internal.callbacks.Response
import com.mercadopago.android.px.model.PaymentRecovery
import com.mercadopago.android.px.model.Token
import com.mercadopago.android.px.model.exceptions.MercadoPagoError
import com.mercadopago.android.px.tracking.internal.MPTracker
import com.mercadopago.android.px.tracking.internal.events.CVVRecoveryFrictionTrack
import com.mercadopago.android.px.tracking.internal.model.Reason
internal class CVVRecoveryWrapper(cardTokenRepository: CardTokenRepository,
private val escManagerBehaviour: ESCManagerBehaviour,
private val paymentRecovery: PaymentRecovery,
private val tracker: MPTracker) {
private val tokenCreationWrapper: TokenCreationWrapper =
TokenCreationWrapper.Builder(cardTokenRepository, escManagerBehaviour).with(paymentRecovery).build()
private val card = paymentRecovery.card
private val token = paymentRecovery.token
suspend fun recoverWithCVV(cvv: String): Response<Token, MercadoPagoError> {
var response: Response<Token, MercadoPagoError> = Response.Failure(MercadoPagoError.createNotRecoverable(""))
if (hasToCloneToken() && tokenCreationWrapper.validateCVVFromToken(cvv)) {
response = tokenCreationWrapper.cloneToken(cvv)
} else if (isSavedCardWithESC() || hasToRecoverTokenFromESC()) {
response = tokenCreationWrapper.createTokenWithEsc(cvv)
} else if (isSavedCardWithoutESC()) {
response = tokenCreationWrapper.createTokenWithoutEsc(cvv)
}
response.resolve(error = { CVVRecoveryFrictionTrack.with(card, Reason.from(paymentRecovery))?.let {
tracker.track(it)
} })
return response
}
private fun hasToCloneToken() = token?.run { cardId.isNullOrEmpty() } ?: false
private fun hasToRecoverTokenFromESC() = paymentRecovery.isStatusDetailInvalidESC &&
(token?.cardId.isNotNullNorEmpty() || card?.id.isNotNullNorEmpty())
private fun isSavedCardWithESC() = card != null && escManagerBehaviour.isESCEnabled
private fun isSavedCardWithoutESC() = card != null && !escManagerBehaviour.isESCEnabled
}
| 38 | Java | 69 | 94 | f5cfa00ea5963f9153a237c3f329af5d2d6cd87f | 2,417 | px-android | MIT License |
plugins/cloudopt-next-polyglot/src/main/kotlin/net/cloudopt/next/polyglot/Polygloter.kt | cloudoptlab | 117,033,346 | false | {"Kotlin": 438045, "HTML": 4325, "Python": 163, "Handlebars": 149, "FreeMarker": 148, "CSS": 23} | package net.cloudopt.next.polyglot
import net.cloudopt.next.core.Resourcer
import org.graalvm.polyglot.*
/**
* Evaluates a source object by using the language specified in the source.
* The result is accessible as value and never returns null.
*
* @param members Sets the value of a member using an identifier
* @param autoContextClose If autoContextClose is turned on, the context
* object will be closed automatically when the execution of the code is
* finished
* @param customContext The context objects was created by yourself
* @param block Code in the specified language, if there is only one line
* of text and it ends in .py this file will be executed automatically
*
* @return Value Represents a polyglot value that can be accessed using a
* set of language agnostic operations. Polyglot values represent values
* from host or guest language. Polyglot values are bound to a context.
* If the context is closed then all value operations throw an
* IllegalStateException.
*/
fun python(
members: MutableMap<String, Any> = mutableMapOf(),
autoContextClose: Boolean = true,
customContext: Context? = null,
block: () -> String
): Value? {
return runOnGraal(members, autoContextClose, customContext, "python", block.invoke())
}
/**
* Evaluates a source object by using the language specified in the source.
* The result is accessible as value and never returns null.
*
* @param members Sets the value of a member using an identifier
* @param autoContextClose If autoContextClose is turned on, the context
* object will be closed automatically when the execution of the code is
* finished
* @param customContext The context objects was created by yourself
* @param block Code in the specified language, if there is only one line
* of text and it ends in .js this file will be executed automatically
*
* @return Value Represents a polyglot value that can be accessed using a
* set of language agnostic operations. Polyglot values represent values
* from host or guest language. Polyglot values are bound to a context.
* If the context is closed then all value operations throw an
* IllegalStateException.
*/
fun javascript(
members: MutableMap<String, Any> = mutableMapOf(),
autoContextClose: Boolean = true,
customContext: Context? = null,
block: () -> String
) {
runOnGraal(members, autoContextClose, customContext, "js", block.invoke())
}
/**
* Evaluates a source object by using the language specified in the source.
* The result is accessible as value and never returns null.
*
* @param members Sets the value of a member using an identifier
* @param autoContextClose If autoContextClose is turned on, the context
* object will be closed automatically when the execution of the code is
* finished
* @param customContext The context objects was created by yourself
* @param block Code in the specified language, if there is only one line
* of text and it ends in .r this file will be executed automatically
*
* @return Value Represents a polyglot value that can be accessed using a
* set of language agnostic operations. Polyglot values represent values
* from host or guest language. Polyglot values are bound to a context.
* If the context is closed then all value operations throw an
* IllegalStateException.
*/
fun R(
members: MutableMap<String, Any> = mutableMapOf(),
autoContextClose: Boolean = true,
customContext: Context? = null,
block: () -> String
) {
runOnGraal(members, autoContextClose, customContext, "R", block.invoke())
}
/**
* Evaluates a source object by using the language specified in the source.
* The result is accessible as value and never returns null.
*
* @param members Sets the value of a member using an identifier
* @param autoContextClose If autoContextClose is turned on, the context
* object will be closed automatically when the execution of the code is
* finished
* @param customContext The context objects was created by yourself
* @param block Code in the specified language, if there is only one line
* of text and it ends in .ruby this file will be executed automatically
*
* @return Value Represents a polyglot value that can be accessed using a
* set of language agnostic operations. Polyglot values represent values
* from host or guest language. Polyglot values are bound to a context.
* If the context is closed then all value operations throw an
* IllegalStateException.
*/
fun ruby(
members: MutableMap<String, Any> = mutableMapOf(),
autoContextClose: Boolean = true,
customContext: Context? = null,
block: () -> String
) {
runOnGraal(members, autoContextClose, customContext, "ruby", block.invoke())
}
/**
* Evaluates a source object by using the language specified in the source.
* The result is accessible as value and never returns null.
*
* @param members Sets the value of a member using an identifier
* @param autoContextClose If autoContextClose is turned on, the context
* object will be closed automatically when the execution of the code is
* finished
* @param customContext The context objects was created by yourself
* @param language Specify the language name
* @param block Code in the specified language, if there is only one line
* of text and it ends in .py this file will be executed automatically
*
* @return Value Represents a polyglot value that can be accessed using a
* set of language agnostic operations. Polyglot values represent values
* from host or guest language. Polyglot values are bound to a context.
* If the context is closed then all value operations throw an
* IllegalStateException.
*/
private fun runOnGraal(
members: MutableMap<String, Any>,
autoContextClose: Boolean,
customContext: Context?,
language: String,
block: String
): Value? {
val context: Context = customContext ?: Context.newBuilder()
.allowIO(true)
.allowPolyglotAccess(PolyglotAccess.ALL)
.allowEnvironmentAccess(EnvironmentAccess.INHERIT)
.allowNativeAccess(true)
.build()
members.keys.forEach { key ->
context.polyglotBindings.putMember(key, members[key])
}
val lineSeparator = System.getProperty("line.separator", "\n")
val blockArray = block.split(lineSeparator)
val source = if (blockArray.size < 2
&& (blockArray[0].contains(".py")
|| blockArray[0].contains(".js")
|| blockArray[0].contains(".r")
|| blockArray[0].contains(".ruby")
)
) {
Source.newBuilder(language, Resourcer.getUrl(block)).cached(true).build()
} else {
Source.create(language, block)
}
val value = context.eval(source)
if (autoContextClose) {
context.close()
}
return value
} | 3 | Kotlin | 49 | 335 | b6d8f934357a68fb94ef511109a1a6043af4b5b6 | 6,800 | cloudopt-next | Apache License 2.0 |
app/src/main/java/com/example/myquizapp/QuizQuestionActivity.kt | bhaskarshukla002 | 577,795,582 | false | null | package com.example.myquizapp
import android.content.Intent
import android.graphics.Color
import android.graphics.Typeface
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.view.View
import android.widget.*
import androidx.core.content.ContextCompat
class QuizQuestionActivity : AppCompatActivity(), View.OnClickListener {
private var mCurrentPosition: Int=1
private var mQuestionsList: ArrayList<Question>? =null
private var mSelectedOptionPosition : Int =0
private var mUserName : String?=null
private var mCorrectAnswers : Int =0
private var progressBar : ProgressBar? = null
private var tvProgress : TextView? = null
private var tvQuestion : TextView? = null
private var ivImage : ImageView? = null
private var tvOptionOne : TextView? = null
private var tvOptionTwo : TextView? = null
private var tvOptionThree : TextView? = null
private var tvOptionFour : TextView? = null
private var btnSubmit : Button? =null
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_quiz_question)
mUserName = intent.getStringExtra(Constant.USER_NAME)
progressBar = findViewById(R.id.progressBar)
tvProgress= findViewById(R.id.tv_progress)
tvQuestion= findViewById(R.id.tv_question)
ivImage = findViewById(R.id.iv_image)
tvOptionOne = findViewById(R.id.tv_option_one)
tvOptionTwo = findViewById(R.id.tv_option_two)
tvOptionThree = findViewById(R.id.tv_option_three)
tvOptionFour = findViewById(R.id.tv_option_four)
btnSubmit = findViewById(R.id.btn_submit)
mQuestionsList = Constant.getQuestion()
setQuestion()
tvOptionOne?.setOnClickListener(this)
tvOptionTwo?.setOnClickListener(this)
tvOptionThree?.setOnClickListener(this)
tvOptionFour?.setOnClickListener(this)
btnSubmit?.setOnClickListener(this)
}
private fun setQuestion() {
val question: Question = mQuestionsList!![mCurrentPosition - 1]
defaultOptionView()
if(mCurrentPosition == mQuestionsList!!.size){
btnSubmit?.text="FINISH"
}else{
btnSubmit?.text="SUBMIT"
}
ivImage?.setImageResource(question.image)
progressBar?.progress = mCurrentPosition
tvProgress?.text = "$mCurrentPosition/${progressBar?.max}"
tvQuestion?.text = question.question
tvOptionOne?.text = question.optionOne
tvOptionTwo?.text = question.optionTwo
tvOptionThree?.text = question.optionThree
tvOptionFour?.text = question.optionFour
}
override fun onClick(view : View?) {
when(view?.id){
R.id.tv_option_one -> {
tvOptionOne?.let {
selectedOptionView(it, 1)
}
}
R.id.tv_option_two -> {
tvOptionTwo?.let{
selectedOptionView(it, 2)
}
}
R.id.tv_option_three -> {
tvOptionThree?.let{
selectedOptionView(it, 3)
}
}
R.id.tv_option_four -> {
tvOptionFour?.let{
selectedOptionView(it, 4)
}
}
R.id.btn_submit -> {
if(mSelectedOptionPosition == 0){
mCurrentPosition++
when{
mCurrentPosition <= mQuestionsList!!.size -> {
setQuestion()
}
else -> {
val intent= Intent(this, ResultActivity::class.java)
intent.putExtra(Constant.USER_NAME, mUserName)
intent.putExtra(Constant.CORRECT_ANSWER, mCorrectAnswers)
intent.putExtra(Constant.TOTAL_QUESTIONS, mQuestionsList?.size)
startActivity(intent)
finish()
}
}
} else{
val question = mQuestionsList?.get(mCurrentPosition -1)
if(question!!.correctAnswer != mSelectedOptionPosition){
answerView(mSelectedOptionPosition, R.drawable.wrong_option_border_bg)
}else{
mCorrectAnswers++
}
answerView(question.correctAnswer, R.drawable.correct_option_border_bg)
if(mCurrentPosition == mQuestionsList!!.size){
btnSubmit?.text="FINISH"
}else {
btnSubmit?.text ="GO TO NEXT QUESTION"
}
mSelectedOptionPosition =0
}
}
}
}
private fun answerView(answer: Int, drawableView: Int){
when(answer){
1 ->{
tvOptionOne?.background = ContextCompat.getDrawable(
this ,
drawableView
)
}
2 ->{
tvOptionTwo?.background = ContextCompat.getDrawable(
this ,
drawableView
)
}
3 ->{
tvOptionThree?.background = ContextCompat.getDrawable(
this ,
drawableView
)
}
4 ->{
tvOptionFour?.background = ContextCompat.getDrawable(
this ,
drawableView
)
}
}
}
private fun selectedOptionView(tv: TextView, selectedOptionNum: Int){
defaultOptionView()
mSelectedOptionPosition= selectedOptionNum
tv.setTextColor(
Color.parseColor("#363A43")
)
tv.setTypeface(tv.typeface, Typeface.BOLD)
tv.background = ContextCompat.getDrawable(
this,
R.drawable.selected_option_border_bg
)
}
private fun defaultOptionView(){
val options = ArrayList<TextView>()
tvOptionOne?.let{
options.add(0 ,it)
}
tvOptionTwo?.let{
options.add(1,it)
}
tvOptionThree?.let{
options.add(2,it)
}
tvOptionFour?.let{
options.add(3,it)
}
for(option in options){
option.setTextColor(Color.parseColor("#7A8089"))
option.typeface = Typeface.DEFAULT
option.background = ContextCompat.getDrawable(
this,
R.drawable.default_option_border_bg
)
}
}
} | 0 | Kotlin | 0 | 0 | 45cbaebe95e3ebea546ce6592fce9b26f35d9b29 | 6,856 | MyQuizApp | MIT License |
appbars/src/main/java/com/decathlon/vitamin/appbars/PrimaryActionModeCallback.kt | Decathlon | 353,745,954 | false | {"Kotlin": 63972} | package com.decathlon.vitamin.appbars
import android.view.Menu
import android.view.MenuItem
import androidx.annotation.MenuRes
import androidx.appcompat.view.ActionMode
class PrimaryActionModeCallback(
@MenuRes private val menuResId: Int,
private val autoFinishMode: Boolean = true,
private val onActionItemClickListener: ((item: MenuItem) -> Unit)? = null,
private val onActionModeFinishedListener: (() -> Unit)? = null
) : ActionMode.Callback {
private var actionMode: ActionMode? = null
override fun onCreateActionMode(mode: ActionMode, menu: Menu): Boolean {
this.actionMode = mode
mode.menuInflater.inflate(menuResId, menu)
return true
}
override fun onPrepareActionMode(mode: ActionMode, menu: Menu): Boolean {
return false
}
override fun onDestroyActionMode(mode: ActionMode) {
onActionModeFinishedListener?.invoke()
this.actionMode = null
}
override fun onActionItemClicked(mode: ActionMode, item: MenuItem): Boolean {
onActionItemClickListener?.invoke(item)
if (autoFinishMode) {
mode.finish()
}
return true
}
fun finishActionMode() {
actionMode?.finish()
}
fun updateTitle(title: String) {
this.actionMode?.title = title
}
val isActive: Boolean
get() = actionMode != null
} | 7 | Kotlin | 18 | 74 | 7df99d2be901c96239b4ed625e4d92803ae9126b | 1,380 | vitamin-android | Apache License 2.0 |
certificatetransparency/src/test/kotlin/com/appmattus/certificatetransparency/internal/CertificateTransparencyInterceptorIntegrationTest.kt | appmattus | 319,979,095 | false | {"Kotlin": 660714, "Java": 17861} | /*
* Copyright 2021-2024 Appmattus Limited
* Copyright 2020 Babylon Partners Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* File modified by Appmattus Limited
* See: https://github.com/appmattus/certificatetransparency/compare/e3d469df9be35bcbf0f564d32ca74af4e5ca4ae5...main
*/
package com.appmattus.certificatetransparency.internal
import com.appmattus.certificatetransparency.certificateTransparencyInterceptor
import com.appmattus.certificatetransparency.utils.LogListDataSourceTestFactory
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.tls.HandshakeCertificates
import org.junit.Test
import javax.net.ssl.SSLPeerUnverifiedException
internal class CertificateTransparencyInterceptorIntegrationTest {
companion object {
private const val invalidSctDomain = "no-sct.badssl.com"
private val networkInterceptor = certificateTransparencyInterceptor {
logListDataSource {
LogListDataSourceTestFactory.realLogListDataSource
}
}
private val networkInterceptorAllowFails = certificateTransparencyInterceptor {
logListDataSource {
LogListDataSourceTestFactory.realLogListDataSource
}
failOnError = false
}
private val clientCertificates: HandshakeCertificates = HandshakeCertificates.Builder()
.addInsecureHost(invalidSctDomain)
.addPlatformTrustedCertificates()
.build()
}
@Test
fun appmattusAllowed() {
val client = OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addNetworkInterceptor(networkInterceptor)
.build()
val request = Request.Builder()
.url("https://www.appmattus.com")
.build()
client.newCall(request).execute()
}
@Test
fun insecureConnectionAllowed() {
val client = OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addNetworkInterceptor(networkInterceptor)
.build()
val request = Request.Builder()
.url("http://www.appmattus.com")
.build()
client.newCall(request).execute()
}
@Test(expected = SSLPeerUnverifiedException::class)
fun invalidDisallowedWithException() {
val client = OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addNetworkInterceptor(networkInterceptor)
.build()
val request = Request.Builder()
.url("https://$invalidSctDomain/")
.build()
client.newCall(request).execute()
}
@Test
fun invalidAllowedWhenFailsAllowed() {
val client = OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addNetworkInterceptor(networkInterceptorAllowFails)
.build()
val request = Request.Builder()
.url("https://$invalidSctDomain/")
.build()
client.newCall(request).execute()
}
@Test
fun invalidAllowedWhenSctNotChecked() {
val client =
OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addNetworkInterceptor(
certificateTransparencyInterceptor {
-invalidSctDomain
logListDataSource {
LogListDataSourceTestFactory.realLogListDataSource
}
}
)
.build()
val request = Request.Builder()
.url("https://$invalidSctDomain/")
.build()
client.newCall(request).execute()
}
@Test(expected = SSLPeerUnverifiedException::class)
fun invalidNotAllowedWhenAllHostsIncluded() {
val client =
OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addNetworkInterceptor(
certificateTransparencyInterceptor {
logListDataSource {
LogListDataSourceTestFactory.realLogListDataSource
}
}
)
.build()
val request = Request.Builder()
.url("https://$invalidSctDomain/")
.build()
client.newCall(request).execute()
}
@Test(expected = IllegalStateException::class)
fun interceptorThrowsException() {
val client = OkHttpClient.Builder()
.sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
.addInterceptor(networkInterceptor)
.build()
val request = Request.Builder()
.url("https://www.appmattus.com")
.build()
client.newCall(request).execute()
}
}
| 20 | Kotlin | 29 | 145 | 2668b1194ae49496e8aa30d3b9022568c5efc6af | 5,705 | certificatetransparency | Apache License 2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.