path
stringlengths 4
297
| contentHash
stringlengths 1
10
| content
stringlengths 0
13M
|
|---|---|---|
Ifood_clone/domain/src/test/java/com/example/domain/ExampleUnitTest.kt | 1444988354 | package com.example.domain
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} |
Ifood_clone/domain/src/main/java/com/example/domain/repository/IAutenticacaoRepository.kt | 1216814257 | package com.example.domain.repository
import com.example.ifood_app.domain.model.Usuario
interface IAutenticacaoRepository {
suspend fun cadastrarUsuario(usuario: Usuario):Boolean
suspend fun logarUsuario(usuario: Usuario):Boolean
suspend fun isLogged():Boolean
} |
Ifood_clone/domain/src/main/java/com/example/domain/repository/ILojaReppsitory.kt | 1979976599 | package com.example.domain.repository
import com.example.ifood_app.domain.model.Loja
interface ILojaReppsitory {
suspend fun cadastrar(Loja : Loja):Boolean
} |
Ifood_clone/domain/src/main/java/com/example/domain/repository/LojaRepositoryImpl.kt | 3338433423 | package com.example.domain.repository
import com.example.ifood_app.domain.model.Loja
import com.google.firebase.firestore.FirebaseFirestore
import javax.inject.Inject
class LojaRepositoryImpl @Inject constructor(
private val auth :FirebaseFirestore
): ILojaReppsitory {
override suspend fun cadastrar(Loja: Loja): Boolean {
//TODO cadastra usuario
return true
}
} |
Ifood_clone/domain/src/main/java/com/example/domain/model/Adcional.kt | 3063488457 | package com.example.ifood_app.domain.model
data class Adcional(
val titulo :String,
val descricao :String,
val preco:String,
val urlImagem :String,
)
|
Ifood_clone/domain/src/main/java/com/example/domain/model/Loja.kt | 3735064813 | package com.example.ifood_app.domain.model
data class Loja(
val nome :String,
val fotoPerfil:String,
val imageCapa:String,
val categoria:Int,
val razaoSocial:String,
val cnpj:String,
val email:String,
val telefone:String,
val especialidade:String,
)
|
Ifood_clone/domain/src/main/java/com/example/domain/model/Categoria.kt | 1072045837 | package com.example.ifood_app.domain.model
data class Categoria(val nome:String, val urlImagem:String)
|
Ifood_clone/domain/src/main/java/com/example/domain/model/Usuario.kt | 1119528326 | package com.example.ifood_app.domain.model
data class Usuario(
val nome:String= "",
val email:String,
val senha:String,
val telefone:String=""
)
|
Ifood_clone/domain/src/main/java/com/example/domain/model/Produto.kt | 2038291534 | package com.example.ifood_app.domain.model
data class Produto(
val titulo :String,
val descricao :String,
val preco :String,
val precoDesconto :String,
val urlImagem :String
)
|
Ifood_clone/domain/src/main/java/com/example/domain/usecase/ResultadoAutenticao.kt | 937108534 | package com.example.ifood_app.domain.usecase
data class ResultadoAutenticao(
var nomeInvalid: Boolean =false,
var emailInvalid: Boolean =false,
var senhaInvalid: Boolean =false,
var telefoneInvalid: Boolean =false
) {
val sucessoCadastro : Boolean
get() = !(nomeInvalid || emailInvalid || senhaInvalid || telefoneInvalid)
val sucessoLogin : Boolean
get() = !( emailInvalid || senhaInvalid )
}
|
Ifood_clone/domain/src/main/java/com/example/domain/usecase/LojaUseCase.kt | 2456154256 | package com.example.domain.usecase
import com.example.domain.repository.ILojaReppsitory
import com.example.ifood_app.domain.model.Loja
import com.wajahatkarim3.easyvalidation.core.view_ktx.validator
import javax.inject.Inject
class LojaUseCase @Inject constructor(
private val lojaRepositoryImpl: ILojaReppsitory
){
fun validarDadosLoja(loja : Loja): Boolean{
val nome = loja.nome.validator()
.minLength(3)
.nonEmpty()
.maxLength(32)
.check()
val razaoSocial = loja.razaoSocial.validator()
.minLength(3)
.nonEmpty()
.maxLength(150)
.check()
val cnpj = loja.cnpj.validator()
.nonEmpty()
.check()
val categoria = loja.categoria.toString().validator()
.nonEmpty()
.validNumber()
.check()
val especialidade = loja.especialidade.validator()
.minLength(3)
.nonEmpty()
.minLength(32)
.check()
val imageCapa = loja.imageCapa.validator()
.nonEmpty()
.validUrl()
.check()
val fotoPefil = loja.fotoPerfil.validator()
.nonEmpty()
.validUrl()
.check()
if (nome) return false
if (razaoSocial) return false
if (cnpj) return false
if (categoria) return false
if (especialidade) return false
if (fotoPefil) return false
if (imageCapa) return false
return true
}
suspend fun cadastrarLoja(loja :Loja):Boolean{
return try {
lojaRepositoryImpl.cadastrar(loja)
}catch (e : Exception){
e.printStackTrace()
false
}
}
} |
Ifood_clone/domain/src/main/java/com/example/domain/usecase/AutenticaoUseCase.kt | 626805606 | package com.example.domain.usecase
import com.example.domain.repository.IAutenticacaoRepository
import com.example.ifood_app.domain.model.Usuario
import com.example.ifood_app.domain.usecase.ResultadoAutenticao
import com.wajahatkarim3.easyvalidation.core.view_ktx.nonEmpty
import com.wajahatkarim3.easyvalidation.core.view_ktx.validEmail
import com.wajahatkarim3.easyvalidation.core.view_ktx.validator
import javax.inject.Inject
class AutenticaoUseCase @Inject constructor(
private val autenticacaoRepository:IAutenticacaoRepository
) {
fun validarCadastroUsuario(usuario: Usuario): ResultadoAutenticao {
val resultadoAutenticao = ResultadoAutenticao()
if (!usuario.nome.nonEmpty())resultadoAutenticao.nomeInvalid =true
if (!usuario.email.validEmail())resultadoAutenticao.emailInvalid =true
val senha = usuario.senha.validator()
.nonEmpty().minLength(5).check()
if (!senha)resultadoAutenticao.senhaInvalid =true
if (!usuario.email.nonEmpty())resultadoAutenticao.emailInvalid =true
if (!usuario.telefone.nonEmpty())resultadoAutenticao.telefoneInvalid =true
return resultadoAutenticao
}
fun validarLoginUsuario(usuario: Usuario): ResultadoAutenticao {
val resultadoAutenticao = ResultadoAutenticao()
val senha = usuario.senha.validator().nonEmpty().minLength(5).check()
val email = usuario.email.validEmail()
if (!senha)resultadoAutenticao.senhaInvalid =true
if (!email)resultadoAutenticao.emailInvalid =true
if (!usuario.email.nonEmpty())resultadoAutenticao.emailInvalid =true
return resultadoAutenticao
}
suspend fun logarUsuario(usuario: Usuario):Boolean{
try {
return autenticacaoRepository.logarUsuario(usuario)
}catch (ex: Exception){
ex.printStackTrace()
return false
}
}
suspend fun cadastrarUsuario(usuario: Usuario) : Boolean{
try {
return autenticacaoRepository.cadastrarUsuario(usuario)
}catch (ex: Exception){
ex.printStackTrace()
return false
}
}
suspend fun isLogged():Boolean{
return try {
autenticacaoRepository.isLogged()
}catch (ex :Exception){
ex.printStackTrace()
return false
}
}
} |
Ifood_clone/loja/src/androidTest/java/com/example/loja/ExampleInstrumentedTest.kt | 4213157844 | package com.example.loja
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.platform.app.InstrumentationRegistry
import org.junit.Assert.*
import org.junit.Test
import org.junit.runner.RunWith
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.loja", appContext.packageName)
}
} |
Ifood_clone/loja/src/test/java/com/example/loja/ExampleUnitTest.kt | 2688225359 | package com.example.loja
import org.junit.Assert.assertEquals
import org.junit.Test
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/di/AppModule.kt | 148160717 | package com.example.loja.di
import com.example.domain.repository.IAutenticacaoRepository
import com.example.domain.repository.ILojaReppsitory
import com.example.domain.repository.LojaRepositoryImpl
import com.example.domain.usecase.AutenticaoUseCase
import com.example.domain.usecase.LojaUseCase
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.firestore.FirebaseFirestore
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
@Module
@InstallIn(ViewModelComponent::class)
object AppModule {
@Provides
fun providerAuntenticaoUseCase(autenticaoRepositoryImpl: IAutenticacaoRepository): AutenticaoUseCase {
return AutenticaoUseCase(autenticaoRepositoryImpl)
}
@Provides
fun providerLojaUseCase(lojaRepository: ILojaReppsitory):LojaUseCase {
return LojaUseCase(lojaRepository)
}
@Provides
fun providerLojaRepositoryImpl(fireStore :FirebaseFirestore ):LojaRepositoryImpl {
return LojaRepositoryImpl(fireStore)
}
// Injeção duplicada -> instance module
// @Provides
// fun provideAuntenticaoRepository(firebaseAuth: FirebaseAuth): IAutenticacaoRepository {
// return AutenticaoRepositoryImpl(firebaseAuth)
// }
@Provides
fun provideFirebaseFireStore():FirebaseFirestore{
return FirebaseFirestore.getInstance()
}
@Provides
fun provideFirebaseAuth():FirebaseAuth{
return FirebaseAuth.getInstance()
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/di/BaseAplication.kt | 2329700194 | package com.example.loja.di
import android.app.Application
import dagger.hilt.android.HiltAndroidApp
@HiltAndroidApp
class BaseAplication : Application() {
} |
Ifood_clone/loja/src/main/java/com/example/loja/di/InterfaceModule.kt | 189242335 | package com.example.loja.di
import com.example.domain.repository.IAutenticacaoRepository
import com.example.domain.repository.ILojaReppsitory
import com.example.domain.repository.LojaRepositoryImpl
import com.example.loja.data.remote.firebase.repository.repositoryimpl.AutenticaoRepositoryImpl
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.android.components.ViewModelComponent
@Module
@InstallIn(ViewModelComponent::class)
abstract class InterfaceModule {
@Binds
abstract fun bindsIAutenticacaoRepository(autenticaoRepositoryImpl: AutenticaoRepositoryImpl): IAutenticacaoRepository
@Binds
abstract fun bindsLojaRepository(lojaRepositoryImpl: LojaRepositoryImpl): ILojaReppsitory
} |
Ifood_clone/loja/src/main/java/com/example/loja/data/remote/firebase/repository/repositoryimpl/AutenticaoRepositoryImpl.kt | 943231690 | package com.example.loja.data.remote.firebase.repository.repositoryimpl
import com.example.domain.repository.IAutenticacaoRepository
import com.example.ifood_app.domain.model.Usuario
import com.google.firebase.auth.FirebaseAuth
import kotlinx.coroutines.tasks.await
import javax.inject.Inject
class AutenticaoRepositoryImpl @Inject constructor(
private val auth : FirebaseAuth
) : IAutenticacaoRepository {
override suspend fun cadastrarUsuario(usuario: Usuario):Boolean {
return auth.createUserWithEmailAndPassword(
usuario.email,
usuario.senha
).await() != null
}
override suspend fun logarUsuario(usuario: Usuario): Boolean {
return auth.signInWithEmailAndPassword(
usuario.email,
usuario.senha
).await() != null
}
override suspend fun isLogged(): Boolean {
return auth.currentUser != null
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/viewmodel/AutenticacaoViewModel.kt | 3459166556 | package com.example.loja.presentation.viewmodel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.domain.usecase.AutenticaoUseCase
import com.example.ifood_app.domain.model.Usuario
import com.example.ifood_app.domain.usecase.ResultadoAutenticao
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class AutenticacaoViewModel @Inject constructor(
private val authenticateUseCase : AutenticaoUseCase
) :ViewModel() {
private val _carregando = MutableLiveData<Boolean>()
val carregando : LiveData<Boolean>
get() = _carregando
private val _resultadoValidacao = MutableLiveData<ResultadoAutenticao>()
val resultadoValidacao : LiveData<ResultadoAutenticao>
get()= _resultadoValidacao
private val _sucesso = MutableLiveData<Boolean>()
val sucesso : LiveData<Boolean>
get() = _sucesso
private val _isLogged = MutableLiveData<Boolean>()
val isLogged : LiveData<Boolean>
get() = _isLogged
fun logarUsuario(usuario: Usuario){
val resultadoAutenticao = authenticateUseCase.validarLoginUsuario(usuario)
_resultadoValidacao.value = resultadoAutenticao
if(resultadoAutenticao.sucessoLogin){
viewModelScope.launch {
_carregando.value =true
val retorno = authenticateUseCase.logarUsuario(usuario)
_carregando.value =false
_sucesso.postValue(retorno)
}
}
}
fun cadastroUsuario(usuario: Usuario){
val resultadoAutenticao = authenticateUseCase.validarCadastroUsuario(usuario)
_resultadoValidacao.value = resultadoAutenticao
if (resultadoAutenticao.sucessoCadastro){
viewModelScope.launch {
_carregando.value =true
val retorno = authenticateUseCase.cadastrarUsuario(usuario)
_carregando.value =false
_sucesso.postValue(retorno)
}
}
}
fun isLogged(){
viewModelScope.launch {
_carregando.value =true
val results = authenticateUseCase.isLogged()
_isLogged.postValue(results)
_carregando.value =false
}
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/viewmodel/LojaViewModel.kt | 398738269 | package com.example.loja.presentation.viewmodel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.example.domain.usecase.LojaUseCase
import com.example.ifood_app.domain.model.Loja
import dagger.hilt.android.lifecycle.HiltViewModel
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import javax.inject.Inject
@HiltViewModel
class LojaViewModel @Inject constructor(
private val lojaUseCase: LojaUseCase
) :ViewModel(){
private val _resultadoValidacao = MutableLiveData<Boolean>()
val validacao: LiveData<Boolean>
get() = _resultadoValidacao
private val _sucesso = MutableLiveData<Boolean>()
val sucesso: LiveData<Boolean>
get() = _sucesso
fun cadastroUsuario(loja: Loja){
val resultado = lojaUseCase.validarDadosLoja(loja)
_resultadoValidacao.value = resultado
if (resultado){
viewModelScope.launch(Dispatchers.IO) {
val retorno = lojaUseCase.cadastrarLoja(loja)
_sucesso.postValue(retorno)
}
}
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/ui/activitys/MainActivity.kt | 815061126 | package com.example.loja.presentation.ui.activitys
import android.content.Intent
import android.os.Bundle
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.widget.ArrayAdapter
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.MenuProvider
import com.example.loja.R
import com.example.loja.databinding.ActivityMainBinding
import com.google.firebase.auth.FirebaseAuth
class MainActivity : AppCompatActivity() {
private val binding by lazy {
ActivityMainBinding.inflate(layoutInflater)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
inicializar()
}
private fun inicializar() {
iniciarlizarToolbar()
inicializarMenuPrincipal()
// inicializarListeners()
// inicializarObservables()
}
private fun iniciarlizarToolbar() {
val toolbar = binding.includeToolbar.toolbarLoja
setSupportActionBar(toolbar)
supportActionBar?.apply {
title ="Gerenciamneto da Loja"
}
}
private fun inicializarMenuPrincipal() {
addMenuProvider(object :MenuProvider{
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
menuInflater.inflate(R.menu.menu_principal_loja,menu)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
when(menuItem.itemId){
R.id.id_tempo ->{
startActivity(Intent(applicationContext,TaxaTempoActivity::class.java))
}
R.id.menu_cardapio ->{
startActivity(Intent(applicationContext,CardapioActivity::class.java))
}
R.id.id_dados_loja ->{
startActivity(Intent(applicationContext,DadoLojalActivity::class.java))
}
R.id.id_dados_loja ->{}
R.id.id_sair ->{
FirebaseAuth.getInstance().signOut()
finish()
startActivity(Intent(applicationContext, LoginActivity::class.java))
}
}
return true
}
})
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/ui/activitys/DadoLojalActivity.kt | 3668087383 | package com.example.loja.presentation.ui.activitys
import android.Manifest
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.ArrayAdapter
import android.widget.Toast
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.activity.viewModels
import androidx.core.content.ContextCompat
import com.example.core.esconderTeclado
import com.example.core.exibirMensagem
import com.example.ifood_app.domain.model.Loja
import com.example.loja.databinding.ActivityDadosLojaBinding
import com.example.loja.presentation.viewmodel.LojaViewModel
import com.google.firebase.auth.FirebaseAuth
import com.google.firebase.storage.FirebaseStorage
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class DadoLojalActivity : AppCompatActivity() {
private val binding by lazy {
ActivityDadosLojaBinding.inflate(layoutInflater)
}
private val lojaViewModel by viewModels<LojaViewModel>()
private var uriImagemSelecionada: Uri? = null
private var temPermissaoGaleria = false
private lateinit var gerenciadorPermissoes : ActivityResultLauncher <Array<String>>
private val abrirGaleria = registerForActivityResult(
ActivityResultContracts.GetContent()
){ uri ->
if(uri != null){
binding.imagePerfilLoja.setImageURI( uri )
uriImagemSelecionada = uri
}else{
exibirMensagem("Nenhuma imagem selecionada")
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
inicializar()
}
private fun inicializar() {
//solicitarPermissoes()
inicializarListeners()
inicializarObservables()
inicializarToolbar()
inicializarSpinner()
inicializarConfiguracoesGaleria()
}
private fun inicializarObservables() {
lojaViewModel.validacao.observe(this){rValidacao->
if (!rValidacao){
exibirMensagem("Preencha todos os campos para prosseguir")
}
}
lojaViewModel.sucesso.observe(this){sucessocadastro ->
if (sucessocadastro){
navegarParaTelaInicial()
exibirMensagem("Sucesso ao cadastrar Loja")
}else{
exibirMensagem("Erro ao cadastrar Loja")
}
}
}
fun navegarParaTelaInicial(){
startActivity(
Intent(this, MainActivity::class.java)
)
finish()
}
private fun inicializarSpinner() {
val categorias = listOf(
"Selecione uma categoria",
"Lanches", "Pizzas", "Japonesa", "Brasileira"
)
binding.spinnerCategorias.adapter = ArrayAdapter(
this,
android.R.layout.simple_spinner_dropdown_item,
categorias
)
}
private fun inicializarToolbar() {
val toolbar = binding.includeToolbar.toolbarLoja
setSupportActionBar(toolbar)
supportActionBar?.apply {
title = "Dados da loja"
setDisplayHomeAsUpEnabled(true)
}
}
private fun solicitarPermissoes() {
//Verificar permissões que o usuário já tem
val permissoesNegadas = mutableListOf<String>()
var temPermissaoGaleria = ContextCompat.checkSelfPermission(
this, Manifest.permission.READ_EXTERNAL_STORAGE
) == PackageManager.PERMISSION_GRANTED
if (!temPermissaoGaleria)
permissoesNegadas.add(Manifest.permission.READ_EXTERNAL_STORAGE)
if (permissoesNegadas.isNotEmpty()) {
gerenciadorPermissoes = registerForActivityResult(
ActivityResultContracts.RequestMultiplePermissions()
){ permissoes: Map<String, Boolean> ->
temPermissaoGaleria = permissoes[Manifest.permission.READ_EXTERNAL_STORAGE]
?: temPermissaoGaleria
}
gerenciadorPermissoes.launch( permissoesNegadas.toTypedArray() )
}
}
private fun inicializarConfiguracoesGaleria() {
binding.btnSelecionarImagemPerfil.setOnClickListener {
if( temPermissaoGaleria ){
abrirGaleria.launch("image/*")//Mime Type
}else{
Toast.makeText(this, "Você não tem permissão de galeria", Toast.LENGTH_SHORT).show()
}
}
}
private fun inicializarListeners() {
with(binding){
edtTelefone.clearFocus()
edtNomeLoja.clearFocus()
edtCnpj.clearFocus()
edtEspecialidade.clearFocus()
edtRazaoSocial.clearFocus()
btnCadastrar.setOnClickListener {
it.esconderTeclado()
lojaViewModel.cadastroUsuario(
Loja(
nome = edtNomeLoja.text.toString(),
razaoSocial = edtRazaoSocial.text.toString(),
cnpj = edtCnpj.text.toString(),
categoria = 1,
especialidade = edtEspecialidade.text.toString(),
imageCapa = "",
fotoPerfil = "",
telefone = edtTelefone.text.toString(),
email = ""
)
)
}
}
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/ui/activitys/CadastroActivity.kt | 998076413 | package com.example.loja.presentation.ui.activitys
import android.content.Intent
import android.os.Bundle
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import com.example.core.AlertaMensagem
import com.example.core.esconderTeclado
import com.example.core.exibirMensagem
import com.example.ifood_app.domain.model.Usuario
import com.example.loja.databinding.ActivityCadastroBinding
import com.example.loja.presentation.viewmodel.AutenticacaoViewModel
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class CadastroActivity : AppCompatActivity() {
private val binding by lazy {
ActivityCadastroBinding.inflate(layoutInflater)
}
private val alertMessage by lazy {
AlertaMensagem(this)
}
private val autenticacaoViewModel : AutenticacaoViewModel by viewModels()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
inicializar()
}
private fun inicializar() {
iniciarlizarToolbar()
inicializarListeners()
inicializarObservables()
}
private fun iniciarlizarToolbar() {
// val toolbar = binding.include2.
//setSupportActionBar(toolbar)
supportActionBar?.apply {
title ="Cadastrar Usuário"
setDisplayHomeAsUpEnabled(true)
}
}
private fun inicializarObservables() {
autenticacaoViewModel.resultadoValidacao.observe(this){
with(binding){
editCadastroNome.error =
if (it.nomeInvalid)"preencha o nome" else null
editCadastroEmail.error =
if (it.emailInvalid)"preencha o email" else null
editCadastroSenha.error=
if (it.senhaInvalid)"preencha a senha" else null
editCadastroTelefone.error =
if (it.telefoneInvalid) "preencha o telefone" else null
}
}
autenticacaoViewModel.carregando.observe(this){ carregando ->
if (carregando){
alertMessage.call("Cadastrando Usuario...")
}else{
alertMessage.hide()
}
}
autenticacaoViewModel.sucesso.observe(this){
if (it){
navegarParaLogin()
exibirMensagem("Sucesso ao Cadastrar")
}else{
exibirMensagem("Erro ao Cadastrar")
}
}
}
private fun navegarParaLogin() {
startActivity(Intent(this, LoginActivity::class.java))
finish()
}
private fun inicializarListeners() {
with(binding){
editCadastroTelefone.clearFocus()
editCadastroNome.clearFocus()
editCadastroSenha.clearFocus()
editCadastroEmail.clearFocus()
btnCadastrar.setOnClickListener {
it.esconderTeclado()
autenticacaoViewModel.cadastroUsuario(
Usuario(
nome= editCadastroNome.text.toString(),
email = editCadastroEmail.text.toString() ,
senha =editCadastroSenha.text.toString(),
telefone = editCadastroTelefone.text.toString()
)
)
}
}
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/ui/activitys/CardapioActivity.kt | 2131918948 | package com.example.loja.presentation.ui.activitys
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.example.loja.R
class CardapioActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_cardapio)
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/ui/activitys/TaxaTempoActivity.kt | 3424621630 | package com.example.loja.presentation.ui.activitys
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.example.loja.R
class TaxaTempoActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_taxa_tempo)
}
} |
Ifood_clone/loja/src/main/java/com/example/loja/presentation/ui/activitys/LoginActivity.kt | 3737147350 | package com.example.loja.presentation.ui.activitys
import android.content.Intent
import android.os.Bundle
import androidx.activity.viewModels
import androidx.appcompat.app.AppCompatActivity
import com.example.core.AlertaMensagem
import com.example.core.esconderTeclado
import com.example.core.exibirMensagem
import com.example.ifood_app.domain.model.Usuario
import com.example.loja.databinding.ActivityLoginBinding
import com.example.loja.presentation.viewmodel.AutenticacaoViewModel
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class LoginActivity : AppCompatActivity() {
private val binding by lazy {
ActivityLoginBinding.inflate(layoutInflater)
}
private val autenticacaoViewModel : AutenticacaoViewModel by viewModels()
private val alertMensagem by lazy{
AlertaMensagem(this)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
supportActionBar?.hide()
inicializar()
}
private fun inicializar() {
inicializarEventoClick()
inicializarObservables()
}
fun inicializarEventoClick(){
with(binding){
btnCadastre.setOnClickListener {
startActivity(Intent(this@LoginActivity, CadastroActivity::class.java))
}
btnLogin.setOnClickListener { view->
view.esconderTeclado()
edtEmail.clearFocus()
edtLoginSenha.clearFocus()
val usuario = Usuario(
email = edtEmail.text.toString(),
senha = edtLoginSenha.text.toString()
)
autenticacaoViewModel.logarUsuario(usuario)
}
}
}
private fun navegarParaTelaPrincipal() {
startActivity(Intent(this, MainActivity::class.java))
}
private fun inicializarObservables() {
autenticacaoViewModel.resultadoValidacao.observe(this){
with(binding){
edtEmail.error =
if (it.emailInvalid)"preencha o Email" else null
edtLoginSenha.error =
if (it.senhaInvalid)"preencha o Senha" else null
}
}
autenticacaoViewModel.sucesso.observe(this){
if (it){
navegarParaTelaPrincipal()
exibirMensagem("Sucesso ao Logar")
}else{
limparCampos()
exibirMensagem("Erro ao logar,Verique email e senha")
}
}
autenticacaoViewModel.isLogged.observe(this){isLogged ->
if (isLogged) {
exibirMensagem("Entrando...")
navegarParaTelaPrincipal()
}
}
autenticacaoViewModel.carregando.observe(this){carregando ->
if (carregando){
alertMensagem.call("Validando Login..")
}else{
alertMensagem.hide()
}
}
}
private fun limparCampos() {
binding.edtLoginSenha.setText("")
binding.edtLoginSenha.setText("")
}
} |
SplashScreenApp/app/src/androidTest/java/com/vahid/splashscreenapp/ExampleInstrumentedTest.kt | 432181970 | package com.vahid.splashscreenapp
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.vahid.splashscreenapp", appContext.packageName)
}
} |
SplashScreenApp/app/src/test/java/com/vahid/splashscreenapp/ExampleUnitTest.kt | 2324799000 | package com.vahid.splashscreenapp
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} |
SplashScreenApp/app/src/main/java/com/vahid/splashscreenapp/ui/theme/Color.kt | 464391625 | package com.vahid.splashscreenapp.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) |
SplashScreenApp/app/src/main/java/com/vahid/splashscreenapp/ui/theme/Theme.kt | 1580617750 | package com.vahid.splashscreenapp.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun SplashScreenAppTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} |
SplashScreenApp/app/src/main/java/com/vahid/splashscreenapp/ui/theme/Type.kt | 668227336 | package com.vahid.splashscreenapp.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) |
SplashScreenApp/app/src/main/java/com/vahid/splashscreenapp/MainActivity.kt | 2088241747 | package com.vahid.splashscreenapp
import android.animation.ObjectAnimator
import android.os.Bundle
import android.view.View
import android.view.animation.OvershootInterpolator
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.core.animation.doOnEnd
import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
import com.vahid.splashscreenapp.ui.theme.SplashScreenAppTheme
class MainActivity : ComponentActivity() {
private val viewmodel by viewModels<MianViewModel>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
installSplashScreen().apply {
setKeepOnScreenCondition {
!viewmodel.isReady.value
}
setOnExitAnimationListener { screen ->
val zoomX = ObjectAnimator.ofFloat(
screen.iconView,
View.SCALE_X,
0.4f,
0.0f
)
zoomX.interpolator = OvershootInterpolator()
zoomX.duration = 500L
zoomX.doOnEnd { screen.remove() }
val zoomY = ObjectAnimator.ofFloat(
screen.iconView,
View.SCALE_Y,
0.4f,
0.0f
)
zoomY.interpolator = OvershootInterpolator()
zoomY.duration = 500L
zoomY.doOnEnd { screen.remove() }
zoomX.start()
zoomY.start()
}
}
setContent {
SplashScreenAppTheme {
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colorScheme.background
) {
Greeting("Android")
}
}
}
}
}
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
Text(
text = "Hello $name!",
modifier = modifier
)
}
@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
SplashScreenAppTheme {
Greeting("Android")
}
} |
SplashScreenApp/app/src/main/java/com/vahid/splashscreenapp/MianViewModel.kt | 2925536890 | package com.vahid.splashscreenapp
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
class MianViewModel : ViewModel() {
private val _isready = MutableStateFlow(false)
val isReady = _isready.asStateFlow()
init {
viewModelScope.launch {
delay(3000L)
_isready.value = true
}
}
} |
Simple-Calculator-/app/src/androidTest/java/com/example/robota/ExampleInstrumentedTest.kt | 482467407 | package com.example.robota
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.example.robota", appContext.packageName)
}
} |
Simple-Calculator-/app/src/test/java/com/example/robota/ExampleUnitTest.kt | 1521521528 | package com.example.robota
import org.junit.Test
import org.junit.Assert.*
/**
* Example local unit test, which will execute on the development machine (host).
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
class ExampleUnitTest {
@Test
fun addition_isCorrect() {
assertEquals(4, 2 + 2)
}
} |
Simple-Calculator-/app/src/main/java/com/example/robota/ui/theme/Color.kt | 2329181509 | package com.example.robota.ui.theme
import androidx.compose.ui.graphics.Color
val Purple80 = Color(0xFFD0BCFF)
val PurpleGrey80 = Color(0xFFCCC2DC)
val Pink80 = Color(0xFFEFB8C8)
val Purple40 = Color(0xFF6650a4)
val PurpleGrey40 = Color(0xFF625b71)
val Pink40 = Color(0xFF7D5260) |
Simple-Calculator-/app/src/main/java/com/example/robota/ui/theme/Theme.kt | 3819245727 | package com.example.robota.ui.theme
import android.app.Activity
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.runtime.SideEffect
import androidx.compose.ui.graphics.toArgb
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalView
import androidx.core.view.WindowCompat
private val DarkColorScheme = darkColorScheme(
primary = Purple80,
secondary = PurpleGrey80,
tertiary = Pink80
)
private val LightColorScheme = lightColorScheme(
primary = Purple40,
secondary = PurpleGrey40,
tertiary = Pink40
/* Other default colors to override
background = Color(0xFFFFFBFE),
surface = Color(0xFFFFFBFE),
onPrimary = Color.White,
onSecondary = Color.White,
onTertiary = Color.White,
onBackground = Color(0xFF1C1B1F),
onSurface = Color(0xFF1C1B1F),
*/
)
@Composable
fun RobotaTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Dynamic color is available on Android 12+
dynamicColor: Boolean = true,
content: @Composable () -> Unit
) {
val colorScheme = when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
val view = LocalView.current
if (!view.isInEditMode) {
SideEffect {
val window = (view.context as Activity).window
window.statusBarColor = colorScheme.primary.toArgb()
WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = darkTheme
}
}
MaterialTheme(
colorScheme = colorScheme,
typography = Typography,
content = content
)
} |
Simple-Calculator-/app/src/main/java/com/example/robota/ui/theme/Type.kt | 3106681546 | package com.example.robota.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography = Typography(
bodyLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
) |
Simple-Calculator-/app/src/main/java/com/example/robota/Calculator.kt | 2944775997 | package com.example.robota
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.*
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
@Composable
fun Calculator(
state: CalculatorState,
modifier: Modifier = Modifier,
buttonSize: Dp = 64.dp,
buttonSpacing: Dp = 8.dp,
onAction : (CalculatorAction) -> Unit
) {
Box(modifier = modifier.fillMaxHeight()) {
Column(
modifier = Modifier
.fillMaxWidth()
.align(Alignment.BottomCenter),
verticalArrangement = Arrangement.spacedBy(buttonSpacing)
) {
Text(
text = state.number1 + (state.operation?.symbol ?: "") + state.number2,
textAlign = TextAlign.End,
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 32.dp),
fontWeight = FontWeight.Light,
fontSize = 80.sp,
color = Color.White,
maxLines = 2
)
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(buttonSpacing)
) {
CalculatorButton(
symbol = "AC",
modifier = Modifier
.background(Color(0xFFE65100))
.size(buttonSize)
.weight(1f),
textColor = Color.Black,
onClick = {
onAction(CalculatorAction.Clear)
}
)
CalculatorButton(
symbol = "Del",
modifier = Modifier
.background(Color(0xFFE65100))
.size(buttonSize)
.weight(1f),
textColor = Color.Black,
onClick = {
onAction(CalculatorAction.Delete)
}
)
CalculatorButton(
symbol = "/",
modifier = Modifier
.background(Color(0xFFE65100))
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Operation(CalculatorOperation.Divide))
}
)
}
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(buttonSpacing)
) {
CalculatorButton(
symbol = "7",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(7))
}
)
CalculatorButton(
symbol = "8",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(8))
}
)
CalculatorButton(
symbol = "9",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(9))
}
)
CalculatorButton(
symbol = "x",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Operation(CalculatorOperation.Multiply))
}
)
}
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(buttonSpacing)
) {
CalculatorButton(
symbol = "4",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(4))
}
)
CalculatorButton(
symbol = "5",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(5))
}
)
CalculatorButton(
symbol = "6",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(6))
}
)
CalculatorButton(
symbol = "-",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Operation(CalculatorOperation.Subtract))
}
)
}
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(buttonSpacing)
) {
CalculatorButton(
symbol = "1",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(1))
}
)
CalculatorButton(
symbol = "2",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(2))
}
)
CalculatorButton(
symbol = "3",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Number(3))
}
)
CalculatorButton(
symbol = "+",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Operation(CalculatorOperation.Add))
}
)
}
Row(
modifier = Modifier.fillMaxWidth(),
horizontalArrangement = Arrangement.spacedBy(buttonSpacing)
) {
CalculatorButton(
symbol = "0",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(2f),
onClick = {
onAction(CalculatorAction.Number(0))
}
)
CalculatorButton(
symbol = ",",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Decimal)
}
)
CalculatorButton(
symbol = "=",
modifier = Modifier
.background(Color.White)
.size(buttonSize)
.weight(1f),
onClick = {
onAction(CalculatorAction.Calculate)
}
)
}
}
}
}
|
Simple-Calculator-/app/src/main/java/com/example/robota/MainActivity.kt | 3036173869 | package com.example.robota
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import androidx.lifecycle.viewmodel.compose.viewModel
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
val viewModel = viewModel<CalculatorViewModel>()
val state = viewModel.state
val buttonSpacing = 8.dp
Calculator(
state = state,
onAction = viewModel::onAction,
buttonSpacing = buttonSpacing,
modifier = Modifier
.fillMaxWidth()
.background(Color.Black)
.padding(16.dp)
)
}
}
}
|
Simple-Calculator-/app/src/main/java/com/example/robota/ViewModel.kt | 3875368160 | package com.example.robota
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
class CalculatorViewModel : ViewModel() {
var state by mutableStateOf(CalculatorState())
fun onAction(action: CalculatorAction) {
when (action) {
is CalculatorAction.Number -> enterNumber(action.value)
is CalculatorAction.Delete -> delete()
is CalculatorAction.Clear -> state = CalculatorState()
is CalculatorAction.Operation -> enterOperation(action.operation)
is CalculatorAction.Decimal -> enterDecimal()
is CalculatorAction.Calculate -> calculate()
}
}
private fun enterOperation(operation: CalculatorOperation) {
if (state.number1.isNotBlank()) {
state = state.copy(operation = operation)
}
}
private fun calculate() {
val number1 = state.number1.toDoubleOrNull()
val number2 = state.number2.toDoubleOrNull()
if (number1 != null && number2 != null) {
val result = when (state.operation) {
CalculatorOperation.Add -> number1 + number2
CalculatorOperation.Subtract -> number1 - number2
CalculatorOperation.Multiply -> number1 * number2
CalculatorOperation.Divide -> number1 / number2
null -> return
}
state = state.copy(
number1 = result.toString().take(15),
number2 = "",
operation = null
)
}
}
private fun delete() {
when {
state.number2.isNotBlank() -> state = state.copy(
number2 = state.number2.dropLast(1)
)
state.operation != null -> state = state.copy(
operation = null
)
state.number1.isNotBlank() -> state = state.copy(
number1 = state.number1.dropLast(1)
)
}
}
private fun enterDecimal() {
if (state.operation == null && !state.number1.contains(".") && state.number1.isNotBlank()) {
state = state.copy(
number1 = state.number1 + "."
)
return
} else if (!state.number2.contains(".") && state.number2.isNotBlank()) {
state = state.copy(
number2 = state.number2 + "."
)
}
}
private fun enterNumber(number: Int) {
if (state.operation == null) {
if (state.number1.length >= MAX_NUM_LENGTH) {
return
}
state = state.copy(
number1 = state.number1 + number
)
return
}
if (state.number2.length >= MAX_NUM_LENGTH) {
return
}
state = state.copy(
number2 = state.number2 + number
)
}
companion object {
private const val MAX_NUM_LENGTH = 8
}
}
|
Simple-Calculator-/app/src/main/java/com/example/robota/Button.kt | 3788405733 | package com.example.robota
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
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.unit.sp
@Composable
fun CalculatorButton(
symbol: String,
modifier: Modifier,
textColor: Color = Color.Black,
onClick: () -> Unit
) {
Box(
contentAlignment = Alignment.Center,
modifier = Modifier
.clip(shape = CircleShape)
.clickable { onClick() }
.then(modifier)
) {
Text(
text = symbol,
fontSize = 36.sp,
color = textColor
)
}
} |
Simple-Calculator-/app/src/main/java/com/example/robota/State.kt | 577695703 | package com.example.robota
data class CalculatorState(
val number1: String = "",
val number2: String = "",
val operation: CalculatorOperation? = null
)
|
Simple-Calculator-/app/src/main/java/com/example/robota/Operation.kt | 3620250829 | package com.example.robota
enum class CalculatorOperation(val symbol: String) {
Add("+"),
Subtract("-"),
Multiply("x"),
Divide("/")
}
|
Simple-Calculator-/app/src/main/java/com/example/robota/Action.kt | 882964951 | package com.example.robota
sealed class CalculatorAction {
data class Number(val value: Int) : CalculatorAction()
data class Operation(val operation: CalculatorOperation) : CalculatorAction()
object Decimal : CalculatorAction()
object Calculate : CalculatorAction()
object Clear : CalculatorAction()
object Delete : CalculatorAction()
}
|
testes-unitarios/src/test/kotlin/MainTest.kt | 2625089603 | import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import kotlin.test.DefaultAsserter
import kotlin.test.DefaultAsserter.fail
import kotlin.test.fail
/*
Testes Unitários
-> Testam pequenas unidades do código, geralmente funções, garantindo o funcionamento do código.
-> *Obs:* São códigos que irão testar outras partes do código.
-> Gera um processo automatizado de testes:
-> O teste escrito pode ser executado diversas vezes garantindo que a função faz o que propõe
-> Pode ser executado vários testes ao mesmo tempo (*suíte de testes*)
-> reduz a verificação manual como o *debugger ou println*
-> Melhor design de funções.
-> Ferramenta útil para regressão
*/
class MainTest {
var mainClass = Main()
@Test
@DisplayName("Teste do metodo -> ContagemDeLetrasXO")
@Disabled // -> É utilizado para desativar o teste
fun testecontagemDeLetrasXO() {
/*
* Caso seja usado apenas o assertTrue ele para os testes assim que
* algum não passe, para os demais testes aconteceçam independentes
* do problema, deve-se usar o Assertions.assertAll({})
*/
Assertions.assertAll(
{ Assertions.assertTrue(mainClass.contagemDeLetrasXO("xxoo")) },
{ Assertions.assertTrue(mainClass.contagemDeLetrasXO("xxooox")) }
)
}
@Test
@Disabled
fun falhar() {
DefaultAsserter.fail("Não posso terminar essa classe sem finalizar os testes. -> exemplo")
}
@Test
@DisplayName("Teste Portaria")
fun testeVerificarInformacoesNaPortaria() {
Assertions.assertAll({
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
15, "", ""
), "Negado"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
20, "", ""
), "Negado"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
25, "VIP", ""
), "Negado"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
25, "comum", "xt45696"
), "Welcome"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
25, "COMUM", "xt45696"
), "Welcome"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
25, "comum", "86963512"
), "Negado"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
25, "premium", "xl86963512"
), "Welcome"
)
Assertions.assertEquals(
mainClass.verificarInformacoesNaPortaria(
25, "luxo", "XL86963512"
), "Welcome"
)
})
}
} |
testes-unitarios/src/main/kotlin/Main.kt | 2727059038 | class Main() {
fun main() {
println(verificarInformacoesNaPortaria(25, "comum", "Xl"))
}
fun contagemDeLetrasXO(frase: String): Boolean {
var x = 0
var o = 0
frase.let {
for (char: Char in frase.lowercase()) {
if (char == 'x') x++
if (char == 'o') o++
}
if ((x > 0 && o > 0) && x == o) return true
}
return false
}
fun verificarInformacoesNaPortaria(idade: Int, convite: String, codigo: String): String {
if (idade < 18) return "Negado"
if (convite.isNotEmpty()) {
val tipoDoConvite = convite.lowercase()
if (tipoDoConvite != "comum" && tipoDoConvite != "premium" && tipoDoConvite != "luxo")
return "Negado"
if (codigo.isNotEmpty()) {
val tipoCodigo = codigo.lowercase()
return if (tipoDoConvite == "comum" && tipoCodigo.startsWith("xt"))
"Welcome"
else if (tipoDoConvite == "premium" || tipoDoConvite == "luxo" &&
tipoCodigo.startsWith("xl")
) "Welcome"
else "Negado"
}
}
return "Negado"
}
}
|
DwaynePassenz_ST10453003_Assignment-1/app/src/main/java/com/example/myhistorydiscoveryapp/MainActivity.kt | 2726247094 | package com.example.myhistorydiscoveryapp
import android.annotation.SuppressLint
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.EditText
import android.widget.TextView
class MainActivity : AppCompatActivity() {
@SuppressLint("MissingInflatedId")
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val generateHistoryButton = findViewById<Button>(R.id.generateHistoryButton)
val ageEditText = findViewById<EditText>(R.id.ageEditText)
val infoTextView = findViewById<TextView>(R.id.infoTextView)
generateHistoryButton.setOnClickListener {
val ageText = ageEditText.text.toString()
if (ageText.isNotEmpty()) {
val age = ageText.toIntOrNull()
if (age != null) {
val historicFigure = findHistoricFigure(age)
infoTextView.text = "Historic Figure: $historicFigure"
} else {
infoTextView.text = "Please enter a valid age"
}
} else {
infoTextView.text = "Please enter an age"
}
}
}
private fun findHistoricFigure(age: Int): String {
return when {
age in 20..40 -> "Martin Luther King Jr."
age in 41..59 -> "Napoleon Bonaparte"
age in 51..69 -> "Christopher Columbus"
// Add more cases for other age ranges
else -> "No historic figure found for this age"
}
}
}
|
spellDndMultiplatform-backend/src/test/kotlin/spelldnd/ApplicationTest.kt | 734611210 | package spelldnd
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import io.ktor.server.testing.*
import kotlin.test.*
import spelldnd.plugins.*
import kotlin.test.Test
class ApplicationTest {
// @Test
// fun testRoot() = testApplication {
// application {
// configureRouting()
// }
// client.get("/").apply {
// assertEquals(HttpStatusCode.OK, status)
// assertEquals("Hello World!", bodyAsText())
// }
// }
}
|
spellDndMultiplatform-backend/src/main/kotlin/Application.kt | 2141926165 | import io.ktor.server.application.*
import io.ktor.server.cio.*
import io.ktor.server.engine.*
import org.jetbrains.exposed.sql.Database
import com.spelldnd.features.login.configureLoginRouting
import com.spelldnd.features.register.configureRegisterRouting
import com.spelldnd.features.spells.configureSpellsRouting
import com.spelldnd.plugins.*
import java.io.File
@Throws(Exception::class)
fun main() {
val file = File("example.txt")
try {
//throw Exception("Hi There!")
Database.connect(
url = "jdbc:postgresql://localhost:5432/spelldnd",
driver = "org.postgresql.Driver",
user = "postgres",
password = "rfvsikjdrf1"
)
embeddedServer(CIO, port = 8080, host = "0.0.0.0", module = Application::module)
.start(wait = true)
} catch (e: Exception) {
file.appendText(e.toString() + "\n")
}
}
fun Application.module() {
configureLoginRouting()
configureRegisterRouting()
configureSpellsRouting()
configureSerialization()
}
|
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/database/users/UserDTO.kt | 4219710533 | package com.spelldnd.database.users
class UserDTO(
val login: String,
val password: String,
val email: String?,
val username: String
) |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/database/users/Users.kt | 3703962069 | package com.spelldnd.database.users
import org.jetbrains.exposed.sql.Table
import org.jetbrains.exposed.sql.insert
import org.jetbrains.exposed.sql.select
import org.jetbrains.exposed.sql.transactions.transaction
object Users: Table("users") {
private val login = Users.varchar("login", 25)
private val password = Users.varchar("password", 25)
private val username = Users.varchar("username", 30)
private val email = Users.varchar("email", 25)
fun insert(userDTO: UserDTO) {
transaction {
Users.insert {
it[login] = userDTO.login
it[password] = userDTO.password
it[username] = userDTO.username
it[email] = userDTO.email ?: ""
}
}
}
fun fetchUser(login: String): UserDTO? {
return try{
transaction {
val userModel = Users.select { Users.login.eq(login) }.single()
UserDTO(
login = userModel[Users.login],
password = userModel[Users.password],
email = userModel[Users.email],
username = userModel[Users.username]
)
}
} catch (e: Exception) {
null
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/database/spells/Spells.kt | 1971019995 | package com.spelldnd.database.spells
import org.jetbrains.exposed.sql.*
import org.jetbrains.exposed.sql.transactions.transaction
object Spells: Table("spells_ru"){
private val slug = com.spelldnd.database.spells.Spells.varchar("slug", 255)
private val name = com.spelldnd.database.spells.Spells.varchar("name", 255)
private val desc = com.spelldnd.database.spells.Spells.text("desc")
private val higher_level = com.spelldnd.database.spells.Spells.text("higher_level")
private val range = com.spelldnd.database.spells.Spells.text("range")
private val components = com.spelldnd.database.spells.Spells.text("components")
private val material = com.spelldnd.database.spells.Spells.text("material")
private val ritual = com.spelldnd.database.spells.Spells.varchar("ritual", 25)
private val duration = com.spelldnd.database.spells.Spells.text("duration")
private val concentration = com.spelldnd.database.spells.Spells.varchar("concentration", 25)
private val casting_time = com.spelldnd.database.spells.Spells.text("casting_time")
private val level = com.spelldnd.database.spells.Spells.varchar("level", 25)
private val level_int = com.spelldnd.database.spells.Spells.integer("level_int")
private val school = com.spelldnd.database.spells.Spells.varchar("school", 255)
private val dnd_class = com.spelldnd.database.spells.Spells.text("dnd_class")
private val archetype = com.spelldnd.database.spells.Spells.text("archetype")
fun insert(spellDTO: com.spelldnd.database.spells.SpellDTO) {
transaction {
com.spelldnd.database.spells.Spells.insert {
it[com.spelldnd.database.spells.Spells.slug] = spellDTO.slug
it[com.spelldnd.database.spells.Spells.name] = spellDTO.name
it[com.spelldnd.database.spells.Spells.desc] = spellDTO.desc
it[com.spelldnd.database.spells.Spells.higher_level] = spellDTO.higher_level
it[com.spelldnd.database.spells.Spells.range] = spellDTO.range
it[com.spelldnd.database.spells.Spells.components] = spellDTO.components
it[com.spelldnd.database.spells.Spells.material] = spellDTO.material
it[com.spelldnd.database.spells.Spells.ritual] = spellDTO.ritual
it[com.spelldnd.database.spells.Spells.duration] = spellDTO.duration
it[com.spelldnd.database.spells.Spells.concentration] = spellDTO.concentration
it[com.spelldnd.database.spells.Spells.casting_time] = spellDTO.casting_time
it[com.spelldnd.database.spells.Spells.level] = spellDTO.level
it[com.spelldnd.database.spells.Spells.level_int] = spellDTO.level_int
it[com.spelldnd.database.spells.Spells.school] = spellDTO.school
it[com.spelldnd.database.spells.Spells.dnd_class] = spellDTO.dnd_class
it[com.spelldnd.database.spells.Spells.archetype] = spellDTO.archetype
}
}
}
fun delete(slug: String) {
transaction {
com.spelldnd.database.spells.Spells.deleteWhere { com.spelldnd.database.spells.Spells.slug eq slug }
}
}
fun fetchSpell(slug: String): com.spelldnd.database.spells.SpellDTO? {
return try{
transaction {
val spellsModel = com.spelldnd.database.spells.Spells.select { com.spelldnd.database.spells.Spells.slug.eq(slug) }.single()
com.spelldnd.database.spells.SpellDTO(
slug = spellsModel[com.spelldnd.database.spells.Spells.slug],
name = spellsModel[com.spelldnd.database.spells.Spells.name],
desc = spellsModel[com.spelldnd.database.spells.Spells.desc],
higher_level = spellsModel[com.spelldnd.database.spells.Spells.higher_level],
range = spellsModel[com.spelldnd.database.spells.Spells.range],
components = spellsModel[com.spelldnd.database.spells.Spells.components],
material = spellsModel[com.spelldnd.database.spells.Spells.material],
ritual = spellsModel[com.spelldnd.database.spells.Spells.ritual],
duration = spellsModel[com.spelldnd.database.spells.Spells.duration],
concentration = spellsModel[com.spelldnd.database.spells.Spells.concentration],
casting_time = spellsModel[com.spelldnd.database.spells.Spells.casting_time],
level = spellsModel[com.spelldnd.database.spells.Spells.level],
level_int = spellsModel[com.spelldnd.database.spells.Spells.level_int],
school = spellsModel[com.spelldnd.database.spells.Spells.school],
dnd_class = spellsModel[com.spelldnd.database.spells.Spells.dnd_class],
archetype = spellsModel[com.spelldnd.database.spells.Spells.archetype]
)
}
} catch (e: Exception) {
null
}
}
fun fetchAll(): List<com.spelldnd.database.spells.SpellDTO> {
return try {
transaction {
val spellsList = com.spelldnd.database.spells.Spells.selectAll().map {
com.spelldnd.database.spells.SpellDTO(
slug = it[com.spelldnd.database.spells.Spells.slug],
name = it[com.spelldnd.database.spells.Spells.name],
desc = it[com.spelldnd.database.spells.Spells.desc],
higher_level = it[com.spelldnd.database.spells.Spells.higher_level],
range = it[com.spelldnd.database.spells.Spells.range],
components = it[com.spelldnd.database.spells.Spells.components],
material = it[com.spelldnd.database.spells.Spells.material],
ritual = it[com.spelldnd.database.spells.Spells.ritual],
duration = it[com.spelldnd.database.spells.Spells.duration],
concentration = it[com.spelldnd.database.spells.Spells.concentration],
casting_time = it[com.spelldnd.database.spells.Spells.casting_time],
level = it[com.spelldnd.database.spells.Spells.level],
level_int = it[com.spelldnd.database.spells.Spells.level_int],
school = it[com.spelldnd.database.spells.Spells.school],
dnd_class = it[com.spelldnd.database.spells.Spells.dnd_class],
archetype = it[com.spelldnd.database.spells.Spells.archetype]
)
}
println(spellsList::class.simpleName)
spellsList
}
} catch (e: Exception) {
emptyList()
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/database/spells/SpellDTO.kt | 3539364802 | package com.spelldnd.database.spells
import kotlinx.serialization.Serializable
@Serializable
class SpellDTO(
val slug: String,
val name: String,
val desc: String,
val higher_level: String,
val range: String,
val components: String,
val material: String,
val ritual: String,
val duration: String,
val concentration: String,
val casting_time: String,
val level: String,
val level_int: Int,
val school: String,
val dnd_class: String,
val archetype: String
)
|
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/database/tokens/TokenDTO.kt | 2351643611 | package com.spelldnd.database.tokens
class TokenDTO (
val rowId: String,
val login: String,
val token: String
) |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/database/tokens/Tokens.kt | 2350532962 | package com.spelldnd.database.tokens
import org.jetbrains.exposed.sql.Table
import org.jetbrains.exposed.sql.insert
import org.jetbrains.exposed.sql.selectAll
import org.jetbrains.exposed.sql.transactions.transaction
object Tokens: Table("tokens") {
private val id = Tokens.varchar("id", 50)
private val login = Tokens.varchar("login", 25)
private val token = Tokens.varchar("token", 75)
fun insert(tokenDTO: TokenDTO) {
transaction {
Tokens.insert {
it[id] = tokenDTO.rowId
it[login] = tokenDTO.login
it[token] = tokenDTO.token
}
}
}
fun fetchTokens(): List<TokenDTO> {
return try {
transaction {
Tokens.selectAll().toList()
.map {
TokenDTO(
rowId = it[Tokens.id],
token = it[Tokens.token],
login = it[Tokens.login]
)
}
}
} catch (e: Exception) {
emptyList()
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/plugins/Routing.kt | 2863915491 | package com.spelldnd.plugins
import io.ktor.server.application.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import kotlinx.serialization.Serializable
@Serializable
data class Test(
val text: String
)
fun Application.configureRouting() {
routing {
get("/") {
call.respond(Test(text = "Hello world"))
}
}
}
|
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/plugins/Serialization.kt | 810834156 | package com.spelldnd.plugins
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.plugins.contentnegotiation.*
fun Application.configureSerialization() {
install(ContentNegotiation) {
json()
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/register/RegisterController.kt | 1824787662 | package com.spelldnd.features.register
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import org.jetbrains.exposed.exceptions.ExposedSQLException
import com.spelldnd.database.tokens.TokenDTO
import com.spelldnd.database.tokens.Tokens
import com.spelldnd.database.users.UserDTO
import com.spelldnd.database.users.Users
import com.spelldnd.utils.isValidEmail
import java.util.*
class RegisterController(private val call: ApplicationCall) {
suspend fun registerNewUser() {
val registerReceiveRemote = call.receive<RegisterReceiveRemote>()
if (!registerReceiveRemote.email.isValidEmail()) {
call.respond(HttpStatusCode.BadRequest, "Email is not valid")
}
val userDTO = Users.fetchUser(registerReceiveRemote.login)
if (userDTO != null) {
call.respond(HttpStatusCode.Conflict, "User already exists")
} else {
val token = UUID.randomUUID().toString()
try {
Users.insert(
UserDTO(
login = registerReceiveRemote.login,
password = registerReceiveRemote.password,
email = registerReceiveRemote.email ?: "",
username = ""
)
)
} catch (e: ExposedSQLException) {
call.respond(HttpStatusCode.Conflict, "User already exists")
}
Tokens.insert(
TokenDTO(
rowId = UUID.randomUUID().toString(),
login = registerReceiveRemote.login,
token = token)
)
call.respond(RegisterResponseRemote(token = token))
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/register/RegisterRemote.kt | 993662983 | package com.spelldnd.features.register
import kotlinx.serialization.Serializable
@Serializable
data class RegisterReceiveRemote(
val login: String,
val email: String,
val password: String
)
@Serializable
data class RegisterResponseRemote(
val token: String
)
|
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/register/RegisterRouting.kt | 2893771031 | package com.spelldnd.features.register
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import com.spelldnd.cashe.InMemoryCache
import com.spelldnd.cashe.TokenCache
import com.spelldnd.utils.isValidEmail
import java.util.*
fun Application.configureRegisterRouting() {
routing {
post("/register") {
val registerController = RegisterController(call)
registerController.registerNewUser()
}
}
}
|
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/spells/SpellsRemote.kt | 1576192852 | package com.spelldnd.features.spells
import kotlinx.serialization.Serializable
@Serializable
data class SpellsRequest(
val slug: String,
val name: String,
val desc: String,
val higher_level: String,
val range: String,
val components: String,
val material: String,
val ritual: String,
val duration: String,
val concentration: String,
val casting_time: String,
val level: String,
val level_int: Int,
val school: String,
val dnd_class: String,
val archetype: String,
)
@Serializable
data class SpellsResponse(
val slug: String,
val name: String,
val desc: String,
val higher_level: String,
val range: String,
val components: String,
val material: String,
val ritual: String,
val duration: String,
val concentration: String,
val casting_time: String,
val level: String,
val level_int: Int,
val school: String,
val dnd_class: String,
val archetype: String,
)
@Serializable
data class FetchSpellsRequest(
val searchQuery: String
)
data class FetchSpellRequest(
val slug: String
) |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/spells/SpellsController.kt | 1743788685 | package com.spelldnd.features.spells
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import org.jetbrains.exposed.exceptions.ExposedSQLException
import com.spelldnd.database.spells.SpellDTO
import com.spelldnd.database.spells.Spells
class SpellsController(private val call: ApplicationCall) {
suspend fun createSpell() {
val receive = call.receive<SpellsRequest>()
if (receive.slug.isEmpty()) {
call.respond(HttpStatusCode.BadRequest, "slug is empty")
}
val spellsDTO = com.spelldnd.database.spells.Spells.fetchSpell(receive.slug)
if (spellsDTO != null) {
call.respond(HttpStatusCode.Conflict, "User already exists")
} else {
try {
com.spelldnd.database.spells.Spells.insert(
com.spelldnd.database.spells.SpellDTO(
slug = receive.slug,
name = receive.name,
desc = receive.desc,
higher_level = receive.higher_level,
range = receive.range,
components = receive.components,
material = receive.material,
ritual = receive.ritual,
duration = receive.duration,
concentration = receive.concentration,
casting_time = receive.casting_time,
level = receive.level,
level_int = receive.level_int,
school = receive.school,
dnd_class = receive.dnd_class,
archetype = receive.archetype
)
)
} catch (e: ExposedSQLException) {
call.respond(HttpStatusCode.Conflict, "Spell already exists")
}
call.respond("Spell added")
}
}
suspend fun addSpells() {
val spellsList = call.receive<List<SpellsRequest>>()
if (spellsList.isEmpty()) {
call.respond(HttpStatusCode.BadRequest, "Empty list of spells")
return
}
for (spell in spellsList) {
if (spell.slug.isEmpty()) {
call.respond(HttpStatusCode.BadRequest, "Slug is empty")
return
}
val spellsDTO = com.spelldnd.database.spells.Spells.fetchSpell(spell.slug)
if (spellsDTO != null) {
call.respond(HttpStatusCode.Conflict, "Spell with slug ${spell.slug} already exists")
return
} else {
try {
com.spelldnd.database.spells.Spells.insert(
com.spelldnd.database.spells.SpellDTO(
slug = spell.slug,
name = spell.name,
desc = spell.desc,
higher_level = spell.higher_level,
range = spell.range,
components = spell.components,
material = spell.material,
ritual = spell.ritual,
duration = spell.duration,
concentration = spell.concentration,
casting_time = spell.casting_time,
level = spell.level,
level_int = spell.level_int,
school = spell.school,
dnd_class = spell.dnd_class,
archetype = spell.archetype
)
)
} catch (e: ExposedSQLException) {
call.respond(HttpStatusCode.Conflict, "Spell with slug ${spell.slug} already exists")
return
}
}
}
call.respond("Spells added")
}
suspend fun deleteSpell() {
val receive = call.receive<SpellsRequest>()
val spell = com.spelldnd.database.spells.Spells.fetchSpell(receive.slug)
if (spell == null) {
call.respond(HttpStatusCode.NotFound, "Spell not found")
return
}
com.spelldnd.database.spells.Spells.delete(receive.slug)
call.respond("Spell deleted")
}
suspend fun deleteSpells() {
val receive = call.receive<List<SpellsRequest>>()
if (receive.isEmpty()) {
call.respond(HttpStatusCode.BadRequest, "Empty list of spells")
return
}
for (spell in receive) {
if (spell.slug.isEmpty()) {
call.respond(HttpStatusCode.BadRequest, "Slug is empty")
return
}
try {
com.spelldnd.database.spells.Spells.delete(slug = spell.slug)
} catch (e: ExposedSQLException) {
call.respond(HttpStatusCode.Conflict, "Spell with slug ${spell.slug} already exists")
return
}
}
call.respond("Spells deleted")
}
suspend fun performSearch() {
val searchQuery = call.parameters["searchQuery"] ?: ""
val searchProperties = call.parameters.getAll("searchProperty")?.toSet() ?: emptySet()
if (searchQuery.isBlank()) {
call.respond(com.spelldnd.database.spells.Spells.fetchAll())
} else {
val filteredSpells = com.spelldnd.database.spells.Spells.fetchAll().filter { spell ->
if (searchProperties.isNotEmpty()) {
searchProperties.any { property ->
when (property) {
"name" -> spell.name.contains(searchQuery, ignoreCase = true)
"desc" -> spell.desc.contains(searchQuery, ignoreCase = true)
"higher_level" -> spell.higher_level.contains(searchQuery, ignoreCase = true)
"range" -> spell.range.contains(searchQuery, ignoreCase = true)
"components" -> spell.components.contains(searchQuery, ignoreCase = true)
"material" -> spell.material.contains(searchQuery, ignoreCase = true)
"ritual" -> spell.ritual.contains(searchQuery, ignoreCase = true)
"duration" -> spell.duration.contains(searchQuery, ignoreCase = true)
"concentration" -> spell.concentration.contains(searchQuery, ignoreCase = true)
"casting_time" -> spell.casting_time.contains(searchQuery, ignoreCase = true)
"level" -> spell.level.contains(searchQuery, ignoreCase = true)
"school" -> spell.school.contains(searchQuery, ignoreCase = true)
"dnd_class" -> spell.dnd_class.contains(searchQuery, ignoreCase = true)
"archetype" -> spell.archetype.contains(searchQuery, ignoreCase = true)
else -> false
}
}
} else {
// Если свойство не выбрано, ищем по всем свойствам
spell.name.contains(searchQuery, ignoreCase = true) ||
spell.desc.contains(searchQuery, ignoreCase = true) ||
spell.higher_level.contains(searchQuery, ignoreCase = true) ||
spell.range.contains(searchQuery, ignoreCase = true) ||
spell.components.contains(searchQuery, ignoreCase = true) ||
spell.material.contains(searchQuery, ignoreCase = true) ||
spell.ritual.contains(searchQuery, ignoreCase = true) ||
spell.duration.contains(searchQuery, ignoreCase = true) ||
spell.concentration.contains(searchQuery, ignoreCase = true) ||
spell.casting_time.contains(searchQuery, ignoreCase = true) ||
spell.level.contains(searchQuery, ignoreCase = true) ||
spell.school.contains(searchQuery, ignoreCase = true) ||
spell.dnd_class.contains(searchQuery, ignoreCase = true) ||
spell.archetype.contains(searchQuery, ignoreCase = true)
}
}
call.respond(filteredSpells)
}
}
suspend fun getSpells() {
call.respond(com.spelldnd.database.spells.Spells.fetchAll().toList())
}
suspend fun getSpell(slug: String) {
if (slug.isBlank()) {
call.respond(HttpStatusCode.BadRequest, "Slug parameter is missing")
return
}
val spell = com.spelldnd.database.spells.Spells.fetchSpell(slug)
if (spell == null) {
call.respond(HttpStatusCode.NotFound, "Spell not found")
} else {
call.respond(spell)
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/spells/SpellsRouting.kt | 3439614402 | package com.spelldnd.features.spells
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.routing.*
import io.ktor.server.response.respond
fun Application.configureSpellsRouting() {
routing {
post("/spells/create") {
SpellsController(call).createSpell()
}
post("/spells/add-spells") {
SpellsController(call).addSpells()
}
post("/spells/delete") {
SpellsController(call).deleteSpell()
}
post("/spells/delete-spells") {
SpellsController(call).deleteSpells()
}
get("/spells/search") {
SpellsController(call).performSearch()
}
get("/spells") {
SpellsController(call).getSpells()
}
get("/spells/{slug}") {
val slug = call.parameters["slug"]
if (slug != null) {
SpellsController(call).getSpell(slug)
} else {
call.respond(HttpStatusCode.BadRequest, "Slug parameter is missing")
}
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/login/LoginController.kt | 4001341648 | package com.spelldnd.features.login
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import com.spelldnd.database.tokens.TokenDTO
import com.spelldnd.database.tokens.Tokens
import com.spelldnd.database.users.Users
import java.util.*
class LoginController(private val call: ApplicationCall) {
suspend fun performLogin() {
val receive = call.receive<LoginReceiveRemote>()
val userDTO = Users.fetchUser(receive.login)
println("receive -> $receive, dto -> $userDTO")
if (userDTO == null) {
call.respond(HttpStatusCode.BadRequest, "User not found")
} else {
if (userDTO.password == receive.password) {
val token = UUID.randomUUID().toString()
Tokens.insert(
TokenDTO(
rowId = UUID.randomUUID().toString(),
login = receive.login,
token = token)
)
call.respond(LoginResponseRemote(token = token))
} else {
call.respond(HttpStatusCode.BadRequest, "Invalid password")
}
}
}
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/login/LoginRemote.kt | 1669289579 | package com.spelldnd.features.login
import kotlinx.serialization.Serializable
@Serializable
data class LoginReceiveRemote(
val login: String,
val password: String
)
@Serializable
data class LoginResponseRemote(
val token: String
) |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/features/login/LoginRouting.kt | 1907658270 | package com.spelldnd.features.login
import io.ktor.http.*
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import com.spelldnd.cashe.InMemoryCache
import com.spelldnd.cashe.TokenCache
import com.spelldnd.features.register.RegisterReceiveRemote
import com.spelldnd.plugins.Test
import java.util.UUID
fun Application.configureLoginRouting() {
routing {
post("/login") {
val loginController = LoginController(call)
loginController.performLogin()
}
}
}
|
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/utils/Validator.kt | 1385078378 | package com.spelldnd.utils
fun String.isValidEmail(): Boolean = true |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/utils/TokenCheck.kt | 454744770 | package com.spelldnd.utils
import com.spelldnd.database.tokens.Tokens
object TokenCheck {
fun isTokenValid(token: String): Boolean = Tokens.fetchTokens().firstOrNull { it.token == token } != null
fun isTokenAdmin(token: String): Boolean = token == "bf8487ae-7d47-11ec-90d6-0242ac120003"
} |
spellDndMultiplatform-backend/src/main/kotlin/com/spelldnd/cashe/InMemoryCache.kt | 193790245 | package com.spelldnd.cashe
import com.spelldnd.features.register.RegisterReceiveRemote
data class TokenCache(
val login: String,
val token: String
)
object InMemoryCache {
val userList: MutableList<RegisterReceiveRemote> = mutableListOf()
val token: MutableList<com.spelldnd.cashe.TokenCache> = mutableListOf()
} |
tudas-app/tudas-app/app/src/androidTest/java/com/jolufeja/tudas/ExampleInstrumentedTest.kt | 1537415651 | package com.jolufeja.tudas
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.jolufeja.tudas", appContext.packageName)
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/ChangeEmailFragment.kt | 2320218545 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.EditText
import androidx.fragment.app.Fragment
import com.jolufeja.authentication.UserAuthenticationService
import com.jolufeja.tudas.service.SettingsService
import com.jolufeja.tudas.service.UserSettings
import com.jolufeja.tudas.service.UserSettings.Companion.byAuthenticatedUser
class ChangeEmailFragment(
private val settingsService: SettingsService,
private val authenticationService: UserAuthenticationService
) : Fragment(R.layout.fragment_change_email) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
var saveButton: Button = view.findViewById<View>(R.id.save) as Button
var cancelButton: Button = view.findViewById<View>(R.id.cancel) as Button
cancelButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack();
}
saveButton.setOnClickListener {
val newEmailAddress = view.findViewById<EditText>(R.id.newEmail)
.text.toString()
requireActivity().supportFragmentManager.popBackStack();
}
}
suspend fun updateSettings(emailAddress: String) = with(authenticationService) {
val userSettings = byAuthenticatedUser()
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/FriendsSettingsFragment.kt | 2797814808 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentTransaction
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.FriendsItem
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.service.user.FriendEntry
import com.jolufeja.tudas.service.user.UserService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import org.koin.android.ext.android.get
private val DefaultFriendsList = listOf(
FriendsItem().apply {
id = 0
text = "Such empty :("
}
)
class FriendsSettingsFragment(
private val userService: UserService
) : Fragment(R.layout.fragment_friends_settings) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfFriends: ArrayList<FriendsItem> = ArrayList()
private var finalList: MutableList<ListItem> = mutableListOf()
private suspend fun buildFriendsList() = flow {
either<CommonErrors, Unit> {
emit(emptyList())
val friends = userService
.getFriendsOfCurrentUser()
.bind()
.toFriendsListItems()
val friendsNonEmpty = when (friends.isEmpty()) {
true -> DefaultFriendsList
false -> friends
}
emit(friendsNonEmpty)
}.fold(
ifLeft = {
Log.d("FriendsSettingsFragment", it.toString())
emit(DefaultFriendsList)
},
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
mRecyclerView = view.findViewById(R.id.lists_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
0,
0,
0,
0,
0,
R.layout.card_friends_settings,
0
) {
null
}
}
mRecyclerView!!.adapter = mAdapter
lifecycleScope.launchWhenCreated {
buildFriendsList().collect { friends ->
finalList = friends.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(friends)
mAdapter?.notifyDataSetChanged()
}
}
var addNewFriendsButton: Button = view.findViewById<View>(R.id.add_friends_button) as Button
addNewFriendsButton.setOnClickListener {
val addFriendFragment = AddFriendFragment(get())
val transaction: FragmentTransaction =
requireActivity().supportFragmentManager.beginTransaction()
transaction.replace(
((view as ViewGroup).parent as View).id,
addFriendFragment
)
transaction.addToBackStack("friends_list")
transaction.commit()
}
var cancelButton: TextView = view.findViewById<View>(R.id.back_button) as TextView
cancelButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack();
}
}
}
fun List<FriendEntry>.toFriendsListItems(): List<ListItem> = mapIndexed { i, friendEntry ->
FriendsItem().apply {
id = i
text = friendEntry.name
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/RegistrationFragment.kt | 2921089487 | package com.jolufeja.tudas
import android.view.View
import com.jolufeja.presentation.fragment.DataBoundFragment
import com.jolufeja.tudas.databinding.FragmentRegistrationBinding
class RegistrationFragment : DataBoundFragment<RegistrationViewModel, FragmentRegistrationBinding>(
R.layout.fragment_registration,
RegistrationViewModel::class,
BR.registrationViewModel
) {
override fun createBinding(view: View) = FragmentRegistrationBinding.bind(view)
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/ChallengesPublicFragment.kt | 276971032 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentTransaction
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import arrow.core.Either
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.httpclient.error.ErrorHandler
import com.jolufeja.presentation.viewmodel.FetcherViewModel
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.ChallengesItem
import com.jolufeja.tudas.data.HeaderItem
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.service.challenges.Challenge
import com.jolufeja.tudas.service.challenges.ChallengeService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import org.koin.android.ext.android.get
import org.koin.android.ext.android.inject
import java.time.LocalDate
import java.time.temporal.ChronoUnit
import java.util.*
import java.util.concurrent.TimeUnit
import kotlin.collections.ArrayList
internal val ChallengeErrorHandler = ErrorHandler(CommonErrors::GenericError)
class ChallengesPublicViewModel(
private val challengeService: ChallengeService
) : FetcherViewModel<CommonErrors, List<ListItem>>(ChallengeErrorHandler) {
override suspend fun fetchData(): List<ListItem> =
when (val publicChallenges = challengeService.getPublicChallenges()) {
is Either.Right ->
listOf(HeaderItem("Public Challenges")) + publicChallenges.value.toChallengeListItems()
is Either.Left ->
throw Throwable("Unable to fetch public challenges ${publicChallenges.value}")
}
}
class ChallengesPublicFragment(
private val challengeService: ChallengeService
) : Fragment(R.layout.fragment_challenges_public) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfChallenges: ArrayList<ChallengesItem> = ArrayList()
private var createChallengeButton: Button? = null
private var finalList: MutableList<ListItem> = mutableListOf()
private val viewModel: ChallengesPublicViewModel by inject()
private suspend fun buildChallengeList() = flow<List<ListItem>> {
either<CommonErrors, Unit> {
emit(emptyList())
val publicChallenges = challengeService
.getPublicChallenges()
.bind()
.toChallengeListItems()
emit(publicChallenges)
}.fold(
ifLeft = { emit(emptyList()) },
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val refreshLayout = view.findViewById<SwipeRefreshLayout>(R.id.public_swiperefresh)
refreshLayout?.setOnRefreshListener {
lifecycleScope.launch {
buildChallengeList().collect { challenges ->
refreshLayout.isRefreshing = false
finalList = challenges.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(challenges)
mAdapter?.notifyDataSetChanged()
}
}
}
mRecyclerView = view.findViewById(R.id.challenges_public_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter = context?.let {
RecycleViewAdapter(
it,
finalList,
R.layout.card_challenges_public,
R.layout.card_header,
0,
0,
0,
0,
0
) { item ->
// Open New Fragment
val challengeArgs = Bundle().also { bundle ->
bundle.putSerializable(CHALLENGE_KEY, (item as ChallengesItem).challenge)
}
val individualChallengePublicFragment = IndividualChallengePublicFragment(get())
individualChallengePublicFragment.arguments = challengeArgs
val transaction: FragmentTransaction =
requireActivity().supportFragmentManager.beginTransaction()
transaction.replace(
((view as ViewGroup).parent as View).id,
individualChallengePublicFragment
)
transaction.addToBackStack("challenge_sent_info")
transaction.commit()
item.id.let { Log.d("TAG", it.toString()) }
}
}
mRecyclerView!!.adapter = mAdapter
// Handle Create Challenge Button
createChallengeButton = view.findViewById(R.id.create_challenge_button) as Button
createChallengeButton!!.setOnClickListener {
// Open New Fragment
val individualChallengePublicFragment = IndividualChallengeSentFragment(get())
val transaction: FragmentTransaction =
requireActivity().supportFragmentManager.beginTransaction()
transaction.replace(
((view as ViewGroup).parent as View).id,
individualChallengePublicFragment
)
transaction.addToBackStack("challenge_sent_info")
transaction.commit()
}
lifecycleScope.launch {
buildChallengeList().collect { challenges ->
finalList = challenges.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(challenges)
mAdapter?.notifyDataSetChanged()
}
}
}
}
fun List<Challenge>.toChallengeListItems(): List<ListItem> = mapIndexed { i, publicChallenge ->
ChallengesItem().apply {
val diff = publicChallenge.dueDate.time - Calendar.getInstance().time.time
val diffInDays = TimeUnit.DAYS.convert(diff, TimeUnit.MILLISECONDS)
id = i
title = publicChallenge.name
author = publicChallenge.creator
description = publicChallenge.description
points = publicChallenge.worth
timeLeft = diffInDays.toInt()
challenge = publicChallenge
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/TudasApplication.kt | 3636531746 | package com.jolufeja.tudas
import android.app.Application
import org.koin.android.ext.koin.androidContext
import org.koin.androidx.fragment.koin.fragmentFactory
import org.koin.core.KoinExperimentalAPI
import org.koin.core.context.startKoin
class TudasApplication : Application() {
@KoinExperimentalAPI
override fun onCreate() {
super.onCreate()
startKoin {
androidContext(this@TudasApplication)
fragmentFactory()
modules(ApplicationModule.withDependencies.toList())
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/IndividualChallengeReceivedFragment.kt | 2190006608 | package com.jolufeja.tudas
import android.app.Activity
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.os.Bundle
import android.os.Environment
import android.provider.MediaStore
import android.util.Log
import android.view.View
import android.widget.ImageView
import android.widget.Toast
import androidx.core.content.FileProvider
import androidx.core.net.toFile
import androidx.lifecycle.lifecycleScope
import arrow.core.computations.nullable
import com.jolufeja.presentation.fragment.DataBoundFragment
import com.jolufeja.tudas.databinding.FragmentChallengeReceivedInfoBinding
import com.jolufeja.tudas.service.challenges.ChallengeService
import com.jolufeja.tudas.service.challenges.ProofKind
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
import org.koin.androidx.viewmodel.ext.android.viewModel
import org.koin.core.parameter.parametersOf
import java.io.File
import java.nio.file.Files
import java.nio.file.StandardCopyOption
import java.text.SimpleDateFormat
import java.util.*
sealed class ChallengeErrors(reason: String) : Throwable(reason)
object FailedToGetChallenge : ChallengeErrors("Couldn't retrieve challenge from backend.")
object NonExistentChallenge : ChallengeErrors("No challenge associated with given name found.")
object MissingChallengeName : ChallengeErrors("No challenge name passed to fragment.")
const val CHALLENGE_KEY = "challenge"
class IndividualChallengeReceivedFragment(
private val challengeService: ChallengeService
) :
DataBoundFragment<IndividualChallengeReceivedViewModel, FragmentChallengeReceivedInfoBinding>(
R.layout.fragment_challenge_received_info,
IndividualChallengeReceivedViewModel::class,
BR.challengeReceivedViewModel
) {
companion object {
private const val REQUEST_CODE_CAMERA = 1
private const val REQUEST_CODE_IMAGE = 2
private const val FILE_INTENT_TYPE = "image/*"
}
private lateinit var filePhoto: File
private lateinit var takenImage: Bitmap
private lateinit var viewImage: ImageView
private lateinit var tempPhotoFile: File
private var pictureWasTaken = false
private var pictureWasTakenAsFile = false
override val viewModel: IndividualChallengeReceivedViewModel by viewModel {
val challenge = arguments?.getSerializable(CHALLENGE_KEY) ?: throw MissingChallengeName
parametersOf(challenge)
}
override fun createBinding(view: View) = FragmentChallengeReceivedInfoBinding.bind(view)
private fun createTempImageFile(): File {
val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.GERMANY).format(Date())
val fileName = "JPEG_${timeStamp}_"
val storageDir = requireContext().getExternalFilesDir(Environment.DIRECTORY_PICTURES)
return File.createTempFile(
fileName,
".jpg",
storageDir
)
}
private fun getCamera() {
if ((activity as MainActivity?)!!.hasNoPermissions()) {
(activity as MainActivity?)!!.requestPermission()
}
val takePhotoIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).also {
val photoFile = tempPhotoFile
val photoURI = FileProvider
.getUriForFile(requireContext(), "com.jolufeja.tudas.fileprovider", photoFile)
it.putExtra(MediaStore.EXTRA_OUTPUT, photoURI)
}
startActivityForResult(
takePhotoIntent,
REQUEST_CODE_CAMERA
);
}
private fun getImage() {
if ((activity as MainActivity?)!!.hasNoPermissions()) {
(activity as MainActivity?)!!.requestPermission()
}
val fileIntent = Intent(Intent.ACTION_PICK, MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
fileIntent.type = FILE_INTENT_TYPE
startActivityForResult(fileIntent, REQUEST_CODE_IMAGE);
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
if (requestCode == REQUEST_CODE_CAMERA && resultCode == Activity.RESULT_OK) {
// takenImage = data?.extras?.get("data") as? Bitmap
// viewImage.setImageBitmap(takenImage);
pictureWasTaken = true
val bitmap = BitmapFactory.decodeFile(tempPhotoFile.path)
viewImage.setImageBitmap(bitmap)
}
if (requestCode == REQUEST_CODE_IMAGE && resultCode == Activity.RESULT_OK) {
viewImage.setImageURI(data?.data)
pictureWasTakenAsFile = true
nullable.eager<Unit> {
val uri = data?.data.bind()
val inputStream = requireContext().contentResolver.openInputStream(uri).bind()
val tempFile = createTempImageFile()
Files.copy(inputStream, tempFile.toPath(), StandardCopyOption.REPLACE_EXISTING)
filePhoto = tempFile
Unit
}
}
super.onActivityResult(requestCode, resultCode, data)
}
override fun onViewAndBindingCreated(
view: View,
binding: FragmentChallengeReceivedInfoBinding,
savedInstanceState: Bundle?
) {
tempPhotoFile = createTempImageFile()
viewImage = binding.imageView
binding.addFile.setOnClickListener { getImage() }
binding.openCamera.setOnClickListener { getCamera() }
binding.backButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack()
}
/*
Only try to complete the challenge if the user has selected an image already.
*/
lifecycleScope.launch {
viewModel.completeChallenge.receiveAsFlow().collect { finishChallenge ->
val proof = when {
pictureWasTaken -> ProofKind.ProofImage(tempPhotoFile)
pictureWasTakenAsFile -> ProofKind.ProofImage(filePhoto)
else -> null
}
proof?.let { proofKind ->
challengeService.finishChallengeWithProof(
finishChallenge,
proofKind
).fold(
ifLeft = { err ->
showToast("Could not complete challenge. Please try again.")
},
ifRight = {
showToast("Challenge successfully completed!")
requireActivity().supportFragmentManager.popBackStack()
}
)
}
}
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/CreateGroupFragment.kt | 2681190699 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import android.widget.Button
import android.widget.EditText
import android.widget.ImageView
import android.widget.TextView
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentManager
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.*
import java.util.ArrayList
class CreateGroupFragment : Fragment(R.layout.fragment_create_group) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfFriends: ArrayList<CreateGroupItem> = ArrayList()
private var finalList: ArrayList<ListItem> = ArrayList()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
// Back Button
var backButton: TextView = view.findViewById<View>(R.id.back_button) as TextView
// Send challenge Button
var createButton: Button = view.findViewById<View>(R.id.create_group_button) as Button
// Listener for Back Button to close fragment
backButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack();
}
// Listener for challenge completed button
createButton.setOnClickListener {
// TO DO
}
//adding items in list
for (i in 0..20) {
val friend = CreateGroupItem()
friend.id = i
friend.text = "Marc"
if (i === 5) {
friend.rankingType = 1
} else {
friend.rankingType = 0
}
listOfFriends.add(friend)
}
listOfFriends.forEach {
finalList.add(it)
}
mRecyclerView = view.findViewById(R.id.create_group_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
0,
0,
0,
0,
0,
0,
R.layout.card_friends,
) {
item ->
// Add to group
}
}
mRecyclerView!!.adapter = mAdapter
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/MainActivity.kt | 2441217441 | package com.jolufeja.tudas
import android.Manifest
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.view.View
import android.widget.TextView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.Toolbar
import androidx.core.app.ActivityCompat
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.navigation.NavController
import androidx.navigation.findNavController
import androidx.navigation.ui.setupWithNavController
import com.google.android.material.bottomnavigation.BottomNavigationView
import com.jolufeja.navigation.NavigationEventBus
import com.jolufeja.navigation.eventDrivenNavigation
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
import org.koin.android.ext.android.inject
import org.koin.androidx.fragment.android.setupKoinFragmentFactory
import org.koin.core.KoinExperimentalAPI
fun Fragment.showToast(message: String) {
Toast.makeText(requireContext(), message, Toast.LENGTH_SHORT).show()
}
class MainActivity : AppCompatActivity(R.layout.activity_main) {
private val CHANNEL_ID = "channel_id_test_01"
private val notificationId = 101
val statsChannel: Channel<Int> = Channel()
val permissions = arrayOf(android.Manifest.permission.CAMERA, android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.READ_EXTERNAL_STORAGE)
private val navigationEventBus: NavigationEventBus by inject()
@KoinExperimentalAPI
override fun onCreate(savedInstanceState: Bundle?) {
setupKoinFragmentFactory()
super.onCreate(savedInstanceState)
val bottomNavigationView: BottomNavigationView = findViewById(R.id.bottom_navigation_view)
// toolbar
val toolbar: Toolbar = findViewById(R.id.toolbar);
val toolbarTitle: TextView = findViewById(R.id.toolbar_title);
toolbarTitle.text = "TUDAS";
createNotificationChannel()
val navController = findNavController(R.id.nav_fragment).also {
it.addOnDestinationChangedListener { _, dest, _ ->
if (dest.id == R.id.loginFragment || dest.id == R.id.registrationFragment ) {
bottomNavigationView.visibility = View.GONE
} else {
// Change App Title on Toolbar according to current fragment
when (dest.id ) {
R.id.challengesFragment -> toolbarTitle.text = "Challenges";
R.id.feedFragment -> toolbarTitle.text = "Feed";
R.id.rankingsFragment -> toolbarTitle.text = "Rankings";
R.id.profileFragment -> toolbarTitle.text = "Profile";
else -> { toolbarTitle.text = "TUDAS";
}
}
bottomNavigationView.visibility = View.VISIBLE
}
}
}
bottomNavigationView.setupWithNavController(navController)
lifecycleScope.launch {
navigationEventBus.subscribe { navigationSubscriptions(navController)(it) }
}
updateCoins()
}
private fun updateCoins() {
val pointsLayout = findViewById<TextView>(R.id.user_points_main)
lifecycleScope.launch {
statsChannel.receiveAsFlow().collect {
pointsLayout.text = it.toString()
}
}
}
private fun navigationSubscriptions(navController: NavController) = eventDrivenNavigation(navController) {
register(RegistrationNavigationEvents.PROCEED_TO_HOME, R.id.nav_graph_authenticated)
register(RegistrationNavigationEvents.PROCEED_TO_LOGIN, R.id.loginFragment)
register(LoginNavigationEvents.PROCEED_TO_HOME, R.id.nav_graph_authenticated)
register(LoginNavigationEvents.PROCEED_TO_REGISTRATION, R.id.registrationFragment)
}
fun hasNoPermissions(): Boolean{
return ContextCompat.checkSelfPermission(this,
Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(this,
Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(this,
Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
}
fun requestPermission(){
ActivityCompat.requestPermissions(this, permissions,0)
}
private fun createNotificationChannel() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
val name = "TUDAS Notification Channel"
val descriptionText = "This is the Channel for all TUDAS Notifications"
val importance = NotificationManager.IMPORTANCE_DEFAULT
val channel = NotificationChannel(CHANNEL_ID, name, importance).apply {
description = descriptionText
}
val notificationManager: NotificationManager =
this.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
notificationManager.createNotificationChannel(channel)
}
}
fun sendNotification(title: String, description: String) {
val intent = Intent(this, MainActivity::class.java).apply {
flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
}
val pendingIntent: PendingIntent = PendingIntent.getActivity(this, 0, intent, 0)
val builder = NotificationCompat.Builder(this, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_launcher_foreground)
.setContentTitle(title)
.setContentText(description)
.setContentIntent((pendingIntent))
.setPriority(NotificationCompat.PRIORITY_DEFAULT)
builder.setAutoCancel(true);
with(NotificationManagerCompat.from(this)) {
notify(notificationId, builder.build())
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/LoginFragment.kt | 505073352 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import arrow.core.computations.either
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.presentation.fragment.DataBoundFragment
import com.jolufeja.tudas.databinding.FragmentLoginBinding
import com.jolufeja.tudas.databinding.FragmentRegistrationBinding
import com.jolufeja.tudas.service.user.UserService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
class LoginFragment(
private val userService: UserService
) : DataBoundFragment<LoginViewModel, FragmentLoginBinding>(
R.layout.fragment_login,
LoginViewModel::class,
BR.loginViewModel
) {
override fun createBinding(view: View) = FragmentLoginBinding.bind(view)
override fun onViewAndBindingCreated(
view: View,
binding: FragmentLoginBinding,
savedInstanceState: Bundle?
) {
lifecycleScope.launch {
viewModel.hasLoggedIn.receiveAsFlow().collect {
updatePoints()
}
}
}
private suspend fun updatePoints() {
either<CommonErrors, Unit> {
val currentPoints = userService.getPointsOfCurrentUser().bind()
(activity as MainActivity).statsChannel.trySend(currentPoints)
}.fold(
ifLeft = { Log.d("LoginFragment", "$it")},
ifRight = {}
)
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/IndividualChallengeSentFragment.kt | 1079021943 | package com.jolufeja.tudas
import android.app.DatePickerDialog
import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.*
import androidx.appcompat.widget.SwitchCompat
import androidx.fragment.app.Fragment
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.viewModelScope
import arrow.core.computations.either
import arrow.core.computations.nullable
import com.jolufeja.authentication.UserAuthenticationService
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.navigation.NavigationEventPublisher
import com.jolufeja.presentation.fragment.DataBoundFragment
import com.jolufeja.tudas.databinding.FragmentChallengeSentInfoBinding
import com.jolufeja.tudas.service.challenges.ChallengeService
import com.jolufeja.tudas.service.challenges.InitialChallenge
import com.jolufeja.tudas.service.user.FriendEntry
import com.jolufeja.tudas.service.user.UserService
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
import java.time.DayOfWeek
import java.time.LocalDate
import java.util.*
private val DefaultDueDate = LocalDate.now().plusDays(1)
class IndividualChallengeSentViewModel(
private val navigator: NavigationEventPublisher,
private val challengeService: ChallengeService,
private val authenticationService: UserAuthenticationService
) : ViewModel() {
val challengeName: MutableLiveData<String> = MutableLiveData("")
val creatorName: MutableLiveData<String> = MutableLiveData("")
val description: MutableLiveData<String> = MutableLiveData("")
val dueDate: MutableLiveData<String> = MutableLiveData("")
val reward: MutableLiveData<String> = MutableLiveData("")
val isPublic: MutableLiveData<Boolean> = MutableLiveData(false)
val addressedTo: MutableLiveData<String> = MutableLiveData("")
val worth: MutableLiveData<Int> = MutableLiveData(200)
var recipient: String? = null
var day: Int = Calendar.getInstance().get(Calendar.DAY_OF_MONTH)
var month: Int = Calendar.getInstance().get(Calendar.MONTH)
var year: Int = Calendar.getInstance().get(Calendar.YEAR)
fun calculateTime(): Date {
val calendar: Calendar = Calendar.getInstance()
calendar.set(year, month, day)
return calendar.time
}
val challengeCreated: Channel<Boolean> = Channel()
fun createChallenge() {
viewModelScope.launch {
nullable {
val initialChallenge = InitialChallenge(
challengeName.value.bind(),
authenticationService.authentication.await().user.name,
description.value.bind(),
calculateTime(),
reward.value.bind(),
recipient.bind(),
200
)
challengeService.createChallenge(initialChallenge).fold(
ifLeft = {
Log.d("IndividualChallengeSentViewModel", "Challenge creation failed: $it")
challengeCreated.trySend(false)
},
ifRight = { challengeCreated.trySend(true) }
)
}
}
}
}
class IndividualChallengeSentFragment(
private val userService: UserService
) :
DataBoundFragment<IndividualChallengeSentViewModel, FragmentChallengeSentInfoBinding>(
R.layout.fragment_challenge_sent_info,
IndividualChallengeSentViewModel::class,
BR.challengeSentViewModel
) {
private val friends = flow {
either<CommonErrors, List<FriendEntry>> {
userService.getFriendsOfCurrentUser().bind().also { emit(it) }
}.fold(
ifLeft = { Log.d("ERROR", it.toString()) },
ifRight = { }
)
}
override fun createBinding(view: View): FragmentChallengeSentInfoBinding =
FragmentChallengeSentInfoBinding.bind(view)
override fun onViewAndBindingCreated(
view: View,
binding: FragmentChallengeSentInfoBinding,
savedInstanceState: Bundle?
) {
lifecycleScope.launchWhenCreated {
friends.collect { friendList ->
binding.challengeReceiver.adapter = ArrayAdapter(
requireContext(),
R.layout.support_simple_spinner_dropdown_item,
friendList.map { it.name }
)
}
viewModel.challengeCreated.receiveAsFlow().collect { success ->
if (success) {
showToast("Challenge successfully created!")
requireActivity().supportFragmentManager.popBackStack()
} else {
showToast("Could not create challenge. Please try again.")
}
}
}
binding.challengeTime.setOnClickListener { challengeTime ->
val calendar = Calendar.getInstance()
val picker = DatePickerDialog(requireContext())
picker.setOnDateSetListener { view, year, month, dayOfMonth ->
val dateString = "${dayOfMonth}.${month}.${year}"
viewModel.day = dayOfMonth
viewModel.month = month
viewModel.year = year
binding.challengeTime.setText(dateString)
}
picker.show()
}
binding.backButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack()
}
binding.showGroupsOnlySwitch.setOnCheckedChangeListener { buttonView, isChecked ->
binding.challengeReceiver.isEnabled = !isChecked
when {
isChecked -> viewModel.recipient = "public"
binding.challengeReceiver.adapter.count > 0 -> {
viewModel.recipient = binding.challengeReceiver.adapter.getItem(0).toString()
}
}
}
val itemListener = object : AdapterView.OnItemSelectedListener {
override fun onItemSelected(
parent: AdapterView<*>?,
view: View?,
position: Int,
id: Long
) {
viewModel.recipient = parent?.getItemAtPosition(position).toString()
}
override fun onNothingSelected(parent: AdapterView<*>?) {}
}
binding.challengeReceiver.onItemSelectedListener = itemListener
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/ChallengesFragment.kt | 3696898713 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import androidx.fragment.app.Fragment
import androidx.viewpager2.widget.ViewPager2
import com.google.android.material.tabs.TabLayout
import com.google.android.material.tabs.TabLayoutMediator
import com.jolufeja.tudas.adapters.ViewPagerFragmentAdapter
import org.koin.android.ext.android.get
class ChallengesFragment : Fragment(R.layout.fragment_challenges) {
var tabLayout: TabLayout? = null
var viewPager: ViewPager2? = null
var tabTitles: Array<String> = arrayOf("Received", "Sent", "Public")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
setHasOptionsMenu(true);
tabLayout = view.findViewById(R.id.tabLayout)
viewPager = view.findViewById(R.id.viewPager)
// create a new tab for each challenge fragment
for (item in tabTitles)
tabLayout!!.addTab(tabLayout!!.newTab().setText(item))
tabLayout!!.tabGravity = TabLayout.GRAVITY_FILL
// create adapter
val adapter = ViewPagerFragmentAdapter(
this,
ChallengesReceivedFragment(get()),
ChallengesSentFragment(get()),
ChallengesPublicFragment(get()),
ChallengesReceivedFragment(get())
)
viewPager!!.adapter = adapter
TabLayoutMediator(tabLayout!!, viewPager!!) { tab, position ->
tab.text = tabTitles[position]
}.attach()
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/ApplicationModule.kt | 3497314586 | package com.jolufeja.tudas
import com.jolufeja.authentication.AuthenticationModule
import com.jolufeja.authentication.AuthenticationQualifiers
import com.jolufeja.httpclient.HttpClientModule
import com.jolufeja.navigation.EventDrivenNavigationModule
import com.jolufeja.tudas.service.DefaultSettingsService
import com.jolufeja.tudas.service.SettingsService
import com.jolufeja.tudas.service.challenges.Challenge
import com.jolufeja.tudas.service.challenges.ChallengeService
import com.jolufeja.tudas.service.challenges.DefaultChallengeService
import com.jolufeja.tudas.service.user.DefaultUserService
import com.jolufeja.tudas.service.user.UserService
import get
import org.koin.androidx.fragment.dsl.fragment
import org.koin.androidx.viewmodel.dsl.viewModel
import org.koin.core.module.Module
import org.koin.core.qualifier.qualifier
import org.koin.dsl.module
object ApplicationModule {
private val module = module {
fragment { MainFragment(get(), get()) }
fragment { ChallengesFragment() }
fragment { FeedFragment(get()) }
fragment { ProfileFragment(get(), get()) }
fragment { RankingsFragment() }
fragment { LoginFragment(get()) }
fragment { RegistrationFragment() }
fragment { IndividualChallengeSentFragment(get()) }
fragment { ChallengesPublicFragment(get()) }
fragment { ChallengesReceivedFragment(get()) }
fragment { ChallengesSentFragment(get()) }
fragment { RankingsFriendsFragment(get()) }
fragment { RankingsWorldFragment(get()) }
fragment { IndividualChallengeReceivedFragment(get()) }
fragment { IndividualChallengePublicFragment(get()) }
fragment { AddFriendFragment(get()) }
viewModel { LoginViewModel(get(), get()) }
viewModel { RegistrationViewModel(get(), get()) }
viewModel { IndividualChallengeSentViewModel(get(), get(), get()) }
viewModel { ChallengesPublicViewModel(get()) }
viewModel { (challenge: Challenge) ->
IndividualChallengeReceivedViewModel(challenge)
}
viewModel { (challenge: Challenge) ->
IndividualChallengePublicViewModel(challenge) }
single<UserService> {
DefaultUserService(
get(qualifier(AuthenticationQualifiers.WithUserAuthentication)),
get()
)
}
single<ChallengeService> {
DefaultChallengeService(
get(qualifier(AuthenticationQualifiers.WithUserAuthentication)),
get()
)
}
single<SettingsService> {
DefaultSettingsService(get(qualifier(AuthenticationQualifiers.WithUserAuthentication)))
}
}
private val dependencies
get() = sequenceOf(
HttpClientModule.withDependencies,
EventDrivenNavigationModule.withDependencies,
AuthenticationModule.withDependencies
).reduce(Set<Module>::plus)
val withDependencies
get() = setOf(module) + dependencies
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/RankingsGroupFragment.kt | 2072055320 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.data.RankingItem
import java.util.ArrayList
class RankingsGroupFragment : Fragment(R.layout.fragment_rankings_group){
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfRankings: ArrayList<RankingItem> = ArrayList()
private var finalList: ArrayList<ListItem> = ArrayList()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
//adding items in list
for (i in 0..20) {
val rank = RankingItem()
rank.id = i
rank.ranking = i + 1
rank.name = "Marc"
rank.points = 100000 / (i+1)
if(i === 5){
rank.rankingType = 1
} else {
rank.rankingType = 0
}
listOfRankings.add(rank)
}
listOfRankings.forEach {
finalList.add(it)
}
mRecyclerView = view.findViewById(R.id.rankings_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
0,
0,
0,
R.layout.card_rankings_friends,
0,
0,
0
) {
null
}
}
mRecyclerView!!.adapter = mAdapter
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/LoginViewModel.kt | 1199089665 | package com.jolufeja.tudas
import android.util.Log
import androidx.lifecycle.*
import arrow.core.computations.either
import com.jolufeja.authentication.UserAuthenticationService
import com.jolufeja.authentication.UserCredentials
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.navigation.NavigationEvent
import com.jolufeja.navigation.NavigationEventPublisher
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
enum class LoginNavigationEvents : NavigationEvent {
PROCEED_TO_REGISTRATION,
PROCEED_TO_HOME
}
class LoginViewModel(
private val authenticationService: UserAuthenticationService,
private val navigator: NavigationEventPublisher
) : ViewModel() {
val hasLoggedIn: Channel<Unit> = Channel()
val userNameData: MutableLiveData<String> = MutableLiveData("")
val passwordData: MutableLiveData<String> = MutableLiveData("")
private val userNameState: StateFlow<String> =
userNameData.asFlow().stateIn(viewModelScope, SharingStarted.Lazily, "")
private val passwordState: StateFlow<String> =
passwordData.asFlow().stateIn(viewModelScope, SharingStarted.Lazily, "")
val canPerformLogin: LiveData<Boolean> = combine(
userNameState,
passwordState
) { (userName, password) ->
userName.isNotEmpty() && password.isNotEmpty()
}.asLiveData()
fun performLogin() {
viewModelScope.launch {
val credentials = UserCredentials(userNameState.value, passwordState.value)
authenticationService.login(credentials).fold(
ifLeft = { Log.d("LoginViewModel", "Login failed. $it") },
ifRight = {
hasLoggedIn.trySend(Unit)
navigator.publish(LoginNavigationEvents.PROCEED_TO_HOME)
}
)
}
}
fun switchToRegistration() = navigator.publish(LoginNavigationEvents.PROCEED_TO_REGISTRATION)
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/AddFriendFragment.kt | 859755426 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.Button
import android.widget.EditText
import android.widget.Toast
import android.widget.Toast.LENGTH_SHORT
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import com.jolufeja.tudas.service.user.UserService
class AddFriendFragment(
private val userService: UserService
) : Fragment(R.layout.fragment_add_friend) {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
var newFriendTextField : EditText = view.findViewById<View>(R.id.newFriend) as EditText
var addButton: Button = view.findViewById<View>(R.id.add) as Button
addButton.setOnClickListener {
if (newFriendTextField.text.isEmpty()){
Toast.makeText(requireContext(), "Please enter a username", Toast.LENGTH_SHORT).show() }
else {
lifecycleScope.launchWhenCreated {
val friendName = newFriendTextField.text.toString()
userService.addFriend(friendName).fold(
ifLeft = {
Log.d("AddFriendFragment", "Couldn't add friend: $it")
},
ifRight = {
requireActivity().supportFragmentManager.popBackStack()
}
)
}
}
}
var cancelButton: Button = view.findViewById<View>(R.id.cancel) as Button
cancelButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack();
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/IndividualChallengePublicFragment.kt | 3811413780 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import androidx.lifecycle.lifecycleScope
import com.jolufeja.presentation.fragment.DataBoundFragment
import com.jolufeja.tudas.databinding.FragmentChallengePublicInfoBinding
import com.jolufeja.tudas.service.challenges.Challenge
import com.jolufeja.tudas.service.challenges.ChallengeService
import com.jolufeja.tudas.service.challenges.ProofKind
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch
import org.koin.androidx.viewmodel.ext.android.viewModel
import org.koin.core.parameter.parametersOf
class IndividualChallengePublicViewModel(private val challenge: Challenge) : ViewModel() {
val name = MutableLiveData(challenge.name)
val creator = MutableLiveData(challenge.creator)
val creationDate = MutableLiveData(challenge.creationDate)
val description = MutableLiveData(challenge.description)
val dueDate = MutableLiveData(challenge.dueDate)
val reward = MutableLiveData(challenge.reward)
val worth = MutableLiveData(challenge.worth)
val addressedTo = MutableLiveData(challenge.addressedTo)
val completeChallenge: Channel<Challenge> = Channel()
fun completeChallenge() {
Log.d("IndividualChallengeReceivedViewModel", name.value.toString())
completeChallenge.trySend(challenge)
}
}
class IndividualChallengePublicFragment(
private val challengeService: ChallengeService
) :
DataBoundFragment<IndividualChallengePublicViewModel, FragmentChallengePublicInfoBinding>(
R.layout.fragment_challenge_public_info,
IndividualChallengePublicViewModel::class,
BR.challengePublicViewModel
) {
override val viewModel: IndividualChallengePublicViewModel by viewModel {
val challenge =
arguments?.getSerializable(CHALLENGE_KEY)
?: throw MissingChallengeName
parametersOf(challenge)
}
override fun createBinding(view: View) = FragmentChallengePublicInfoBinding.bind(view)
override fun onViewAndBindingCreated(
view: View,
binding: FragmentChallengePublicInfoBinding,
savedInstanceState: Bundle?
) {
binding.backButton.setOnClickListener {
requireActivity().supportFragmentManager.popBackStack()
}
lifecycleScope.launch {
viewModel.completeChallenge.receiveAsFlow().collect { finishChallenge ->
val proof = ProofKind.SocialMediaLink("Public-Challenge")
challengeService.finishChallengeWithProof(finishChallenge, proof).fold(
ifLeft = { err ->
showToast("Could not complete challenge. Please try again.")
},
ifRight = {
showToast("Challenge successfully completed!")
requireActivity().supportFragmentManager.popBackStack()
}
)
}
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/adapters/ViewPagerFragmentAdapter.kt | 1086351616 | package com.jolufeja.tudas.adapters
import androidx.fragment.app.Fragment
import androidx.viewpager2.adapter.FragmentStateAdapter
import com.jolufeja.tudas.ChallengesPublicFragment
import com.jolufeja.tudas.ChallengesReceivedFragment
import com.jolufeja.tudas.ChallengesSentFragment
// Adapter to create the three challenge fragments
class ViewPagerFragmentAdapter(fragment: Fragment, private val firstPage: Fragment, private val secondPage: Fragment, private val thirdPage: Fragment, private val defaultPage: Fragment) : FragmentStateAdapter(fragment) {
override fun getItemCount(): Int = 3;
override fun createFragment(position: Int): Fragment {
return when (position) {
0 -> {
firstPage;
}
1 -> {
secondPage;
}
2 -> {
thirdPage;
}
else -> defaultPage;
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/adapters/RecycleViewAdapter.kt | 1211662428 | package com.jolufeja.tudas.adapters
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import android.widget.FrameLayout
import android.widget.TextView
import androidx.core.content.ContextCompat
import androidx.recyclerview.widget.RecyclerView
import com.jolufeja.tudas.R
import com.jolufeja.tudas.data.ListItem
import java.util.*
// Adapter to create a challenge card
class RecycleViewAdapter(
private val context: Context,
private var mDataList: List<ListItem>,
private val layoutCard: Int,
private val layoutHeader: Int,
private val layoutFeedCard: Int,
private val layoutRankingCard: Int,
private val layoutGroupsRankingCard: Int,
private val layoutFriendsCard: Int,
private val layoutCreateGroupCard: Int,
private val listener: (ListItem) -> Unit
) :
RecyclerView.Adapter<RecyclerView.ViewHolder>() {
fun refreshData(items: List<ListItem>) {
mDataList = items
}
override fun onCreateViewHolder(
parent: ViewGroup,
viewType: Int
): RecyclerView.ViewHolder {
when (viewType) {
0 -> return CardViewHolder(
LayoutInflater.from(context).inflate(layoutCard, parent, false)
)
2 -> return FeedViewHolder(
LayoutInflater.from(context).inflate(layoutFeedCard, parent, false)
)
3 -> return RankingViewHolder(
LayoutInflater.from(context).inflate(layoutRankingCard, parent, false)
)
4 -> return GroupsViewHolder (
LayoutInflater.from(context).inflate(layoutGroupsRankingCard, parent, false)
)
5 -> return FriendsViewHolder (
LayoutInflater.from(context).inflate(layoutFriendsCard, parent, false)
)
6 -> return CreateGroupViewHolder(
LayoutInflater.from(context).inflate(layoutCreateGroupCard, parent, false)
)
}
return HeaderViewHolder(
LayoutInflater.from(context).inflate(layoutHeader, parent, false)
)
}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
when (mDataList[position].getType()) {
0 -> {
(holder as RecycleViewAdapter.CardViewHolder).bind(position)
}
1 -> {
(holder as RecycleViewAdapter.HeaderViewHolder).bind(position)
}
2 -> {
(holder as RecycleViewAdapter.FeedViewHolder).bind(position)
}
3 -> {
(holder as RecycleViewAdapter.RankingViewHolder).bind(position)
}
4 -> {
(holder as RecycleViewAdapter.GroupsViewHolder).bind(position)
}
5 -> {
(holder as RecycleViewAdapter.FriendsViewHolder).bind(position)
}
6 -> {
(holder as RecycleViewAdapter.CreateGroupViewHolder).bind(position)
}
}
}
override fun getItemCount(): Int {
return mDataList.size
}
override fun getItemViewType(position: Int): Int {
return mDataList[position].getType()
}
private inner class CardViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var title: TextView = itemView.findViewById<View>(R.id.challenge_title) as TextView
var author: TextView =
itemView.findViewById<View>(R.id.challenge_author) as TextView
var timeLeft: TextView =
itemView.findViewById<View>(R.id.challenge_time_left) as TextView
var description: TextView =
itemView.findViewById<View>(R.id.challenge_description) as TextView
var reward: TextView =
itemView.findViewById<View>(R.id.challenge_reward) as TextView
var points: TextView =
itemView.findViewById<View>(R.id.challenge_points) as TextView
var button: Button = itemView.findViewById<View>(R.id.challenge_button) as Button
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
title.text = recyclerViewModel.title
author.text = recyclerViewModel.author
timeLeft.text = "${recyclerViewModel.timeLeft.toString()} days"
reward.text = recyclerViewModel.reward
points.text = recyclerViewModel.points.toString();
description.text = recyclerViewModel.description
// OnClick Listener on Button
button.setOnClickListener { listener(recyclerViewModel) }
}
}
private inner class HeaderViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var text: TextView = itemView.findViewById(R.id.header_text) as TextView
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
text.text = recyclerViewModel.text
}
}
private inner class FeedViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var text: TextView = itemView.findViewById(R.id.feed_text) as TextView
var cardFrameLayout: FrameLayout = itemView.findViewById(R.id.card_feed) as FrameLayout
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
text.text = recyclerViewModel.text
val androidColors : IntArray = context.resources.getIntArray(R.array.colorarray)
val randomAndroidColor: Int = androidColors[Random().nextInt(androidColors.size)]
cardFrameLayout.background.setTint(randomAndroidColor)
}
}
private inner class RankingViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var name: TextView = itemView.findViewById(R.id.ranking_name) as TextView
var ranking: TextView = itemView.findViewById(R.id.ranking_ranking) as TextView
var points: TextView = itemView.findViewById(R.id.ranking_points) as TextView
var cardFrameLayout: FrameLayout = itemView.findViewById(R.id.card_feed) as FrameLayout
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
if(recyclerViewModel.rankingType == 1){
cardFrameLayout.background.setTint(ContextCompat.getColor(context,R.color.orange));
} else {
cardFrameLayout.background.setTint(ContextCompat.getColor(context,R.color.primary));
}
name.text = recyclerViewModel.name
ranking.text = recyclerViewModel.ranking.toString()
points.text = recyclerViewModel.points.toString()
//val androidColors : IntArray = context.resources.getIntArray(R.array.colorarray)
// val randomAndroidColor: Int = androidColors[Random().nextInt(androidColors.size)]
// cardFrameLayout.background.setTint(randomAndroidColor)
}
}
private inner class GroupsViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var groupName: TextView = itemView.findViewById<View>(R.id.group_name) as TextView
var groupSize: TextView =
itemView.findViewById<View>(R.id.group_size) as TextView
var openGroupButton: Button = itemView.findViewById<View>(R.id.open_group_button) as Button
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
groupName.text = recyclerViewModel.name
groupSize.text = recyclerViewModel.size.toString();
// OnClick Listener on Button
openGroupButton.setOnClickListener { listener(recyclerViewModel) }
}
}
private inner class FriendsViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var username: TextView = itemView.findViewById(R.id.friend_username) as TextView
var deleteButton: Button = itemView.findViewById<View>(R.id.delete_button) as Button
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
username.text = recyclerViewModel.text
// OnClick Listener on Button
deleteButton.setOnClickListener { listener(recyclerViewModel) }
}
}
private inner class CreateGroupViewHolder(itemView: View) :
RecyclerView.ViewHolder(itemView) {
var username: TextView = itemView.findViewById(R.id.friend_username) as TextView
var button: Button = itemView.findViewById<View>(R.id.add_friend_to_group) as Button
fun bind(position: Int) {
val recyclerViewModel = mDataList[position]
username.text = recyclerViewModel.text
// OnClick Listener on Button
button.setOnClickListener { listener(recyclerViewModel) }
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/RankingsWorldFragment.kt | 2209388517 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.FeedItem
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.data.RankingItem
import com.jolufeja.tudas.service.user.Ranking
import com.jolufeja.tudas.service.user.User
import com.jolufeja.tudas.service.user.UserService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import java.time.LocalDate
import java.util.ArrayList
class RankingsWorldFragment(
private val userService: UserService
) : Fragment(R.layout.fragment_rankings_world){
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfRankings: ArrayList<RankingItem> = ArrayList()
private var finalList: MutableList<ListItem> = mutableListOf()
private suspend fun buildRankingsList() = flow<List<ListItem>> {
either<CommonErrors, Unit> {
emit(emptyList())
val feedElements = userService
.getPublicRanking()
.bind()
.toRankingListItems()
emit(feedElements)
}.fold(
ifLeft = { emit(emptyList()) },
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
// //adding items in list
// for (i in 0..20) {
// val rank = RankingItem()
// rank.id = i
// rank.ranking = i + 1
// rank.name = "Marc"
// rank.points = 100000 / (i+1)
// if(i === 5){
// rank.rankingType = 1
// } else {
// rank.rankingType = 0
// }
// listOfRankings.add(rank)
// }
//
// listOfRankings.forEach {
// finalList.add(it)
// }
mRecyclerView = view.findViewById(R.id.rankings_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
0,
0,
0,
R.layout.card_rankings_friends,
0,
0,
0
) {
null
}
}
mRecyclerView!!.adapter = mAdapter
lifecycleScope.launch {
buildRankingsList().collect { rankings ->
finalList = rankings.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(rankings)
mAdapter?.notifyDataSetChanged()
}
}
}
}
fun List<Ranking>.toRankingListItems(): List<ListItem> = mapIndexed { i, entry ->
RankingItem().apply {
id = i
ranking = i + 1
name = entry.name
points = entry.points
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/RegistrationViewModel.kt | 1765722010 | package com.jolufeja.tudas
import android.util.Log
import androidx.lifecycle.*
import com.jolufeja.authentication.registration.RegistrationCredentials
import com.jolufeja.authentication.registration.RegistrationService
import com.jolufeja.navigation.NavigationEvent
import com.jolufeja.navigation.NavigationEventPublisher
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
enum class RegistrationNavigationEvents : NavigationEvent {
PROCEED_TO_HOME,
PROCEED_TO_LOGIN
}
class RegistrationViewModel(
private val registrationService: RegistrationService,
private val navigator: NavigationEventPublisher
) : ViewModel() {
val userNameData: MutableLiveData<String> = MutableLiveData("")
val passwordData: MutableLiveData<String> = MutableLiveData("")
val emailAddressData: MutableLiveData<String> = MutableLiveData("")
private val userNameState: StateFlow<String> =
userNameData.asFlow().stateIn(viewModelScope, SharingStarted.Lazily, "")
private val passwordState: StateFlow<String> =
passwordData.asFlow().stateIn(viewModelScope, SharingStarted.Lazily, "")
private val emailAddressState: StateFlow<String> =
emailAddressData.asFlow().stateIn(viewModelScope, SharingStarted.Lazily, "")
val canPerformRegistration: LiveData<Boolean> = combine(
userNameState,
passwordState,
emailAddressState
) { (userName, password, emailAddress) ->
userName.isNotBlank() && password.isNotBlank() && emailAddress.isNotBlank()
}.asLiveData()
fun performRegistration() {
viewModelScope.launch {
val credentials = RegistrationCredentials(
name = userNameState.value,
password = passwordState.value,
email = emailAddressState.value
)
registrationService.registerUser(credentials).fold(
ifLeft = { Log.d("RegistrationViewModel", "Registration failed. $it") },
ifRight = {
navigator.publish(LoginNavigationEvents.PROCEED_TO_HOME)
}
)
}
}
fun switchToLogin() = navigator.publish(RegistrationNavigationEvents.PROCEED_TO_LOGIN)
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/RankingsFriendsFragment.kt | 3381110947 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.data.RankingItem
import com.jolufeja.tudas.service.user.UserService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import java.util.ArrayList
class RankingsFriendsFragment(
private val userService: UserService
) : Fragment(R.layout.fragment_rankings_friends) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfRankings: ArrayList<RankingItem> = ArrayList()
private var finalList: MutableList<ListItem> = mutableListOf()
private suspend fun buildRankingsList() = flow<List<ListItem>> {
either<CommonErrors, Unit> {
emit(emptyList())
val feedElements = userService
.getFriendsRanking()
.bind()
.toRankingListItems()
emit(feedElements)
}.fold(
ifLeft = { emit(emptyList()) },
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
mRecyclerView = view.findViewById(R.id.rankings_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
0,
0,
0,
R.layout.card_rankings_friends,
0,
0,
0
) {
null
}
}
mRecyclerView!!.adapter = mAdapter
lifecycleScope.launch {
buildRankingsList().collect { rankings ->
finalList = rankings.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(rankings)
mAdapter?.notifyDataSetChanged()
}
}
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/FeedFragment.kt | 3003331109 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.authentication.FeedEntry
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.FeedItem
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.service.user.UserService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import java.time.LocalDate
class FeedFragment(
private val userService: UserService
) : Fragment(R.layout.fragment_feed) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfActivities: ArrayList<FeedItem> = ArrayList()
private var finalList: MutableList<ListItem> = mutableListOf()
private suspend fun buildFeedList() = flow<List<ListItem>> {
either<CommonErrors, Unit> {
emit(emptyList())
val feedElements = userService
.getFeed()
.bind()
.toFeedListItems()
emit(feedElements)
}.fold(
ifLeft = {
Log.d("FeedFragment", it.toString())
showToast("Could not fetch feed. Please try again.")
emit(emptyList())
},
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val refreshLayout = view.findViewById<SwipeRefreshLayout>(R.id.feed_swiperefresh)
refreshLayout?.setOnRefreshListener {
lifecycleScope.launch {
buildFeedList().collect { feed ->
refreshLayout.isRefreshing = false
finalList = feed.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(feed)
mAdapter?.notifyDataSetChanged()
}
}
}
mRecyclerView = view.findViewById(R.id.feed_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
0,
R.layout.card_feed_header,
R.layout.card_feed,
0,
0,
0,
0
) {
null
}
}
mRecyclerView!!.adapter = mAdapter
lifecycleScope.launch {
buildFeedList().collect { feed ->
finalList = feed.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(feed)
mAdapter?.notifyDataSetChanged()
}
}
}
}
private fun List<FeedEntry>.toFeedListItems(): List<ListItem> = mapIndexed { i, entry ->
FeedItem().apply {
id = i
text = entry.message
date = LocalDate.now().toString()
type = "Sent challenge"
}
}
|
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/ChallengesSentFragment.kt | 1422998743 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentTransaction
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.ChallengesItem
import com.jolufeja.tudas.data.HeaderItem
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.service.challenges.ChallengeService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import org.koin.android.ext.android.get
class ChallengesSentFragment(
private val challengeService: ChallengeService
) : Fragment(R.layout.fragment_challenges_sent) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfChallenges: ArrayList<ChallengesItem> = ArrayList()
private var createChallengeButton: Button? = null
private var finalList: MutableList<ListItem> = mutableListOf()
private suspend fun buildChallengeList() = flow<List<ListItem>> {
either<CommonErrors, Unit> {
emit(emptyList())
val sentChallenges = challengeService
.getOwnCreatedChallenges()
.bind()
.toChallengeListItems()
val combined = listOf(HeaderItem("Sent Challenges")) + sentChallenges
emit(combined)
}.fold(
ifLeft = { emit(emptyList()) },
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val refreshLayout = view.findViewById<SwipeRefreshLayout>(R.id.sent_swiperefresh)
refreshLayout?.setOnRefreshListener {
lifecycleScope.launch {
buildChallengeList().collect { challenges ->
refreshLayout.isRefreshing = false
finalList = challenges.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(challenges)
mAdapter?.notifyDataSetChanged()
}
}
}
mRecyclerView = view.findViewById(R.id.challenges_sent_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter =
context?.let {
RecycleViewAdapter(
it,
finalList,
R.layout.card_challenges_sent,
R.layout.card_header,
0,
0,
0,
0,
0
) { item ->
// Open New Fragment
val individualChallengeSentFragment = IndividualChallengeSentFragment(get())
val transaction: FragmentTransaction =
requireActivity().supportFragmentManager.beginTransaction()
transaction.replace(
((view as ViewGroup).parent as View).id,
individualChallengeSentFragment
)
transaction.addToBackStack("challenge_sent_info")
transaction.commit()
item.id.let { Log.d("TAG", it.toString()) }
}
}
mRecyclerView!!.adapter = mAdapter
lifecycleScope.launch {
buildChallengeList().collect { challenges ->
finalList = challenges.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(challenges)
mAdapter?.notifyDataSetChanged()
}
}
// Handle Create Challenge Button
createChallengeButton = view.findViewById(R.id.create_challenge_button) as Button
createChallengeButton!!.setOnClickListener {
// Open New Fragment
val individualChallengeSentFragment = IndividualChallengeSentFragment(get())
val transaction: FragmentTransaction =
requireActivity().supportFragmentManager.beginTransaction()
transaction.replace(
((view as ViewGroup).parent as View).id,
individualChallengeSentFragment
)
transaction.addToBackStack("challenge_sent_info")
transaction.commit()
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/RankingsFragment.kt | 1082905579 | package com.jolufeja.tudas
import android.os.Bundle
import android.view.View
import androidx.fragment.app.Fragment
import androidx.viewpager2.widget.ViewPager2
import com.google.android.material.tabs.TabLayout
import com.google.android.material.tabs.TabLayoutMediator
import com.jolufeja.tudas.adapters.ViewPagerFragmentAdapter
import org.koin.android.ext.android.get
class RankingsFragment : Fragment(R.layout.fragment_rankings) {
var tabLayout: TabLayout? = null
var viewPager: ViewPager2? = null
var tabTitles: Array<String> = arrayOf("Friends", "Groups", "World")
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
setHasOptionsMenu(true);
tabLayout = view.findViewById<TabLayout>(R.id.tabLayout)
viewPager = view.findViewById<ViewPager2>(R.id.viewPager)
// create a new tab for each rankings fragment
for (item in tabTitles)
tabLayout!!.addTab(tabLayout!!.newTab().setText(item))
tabLayout!!.tabGravity = TabLayout.GRAVITY_FILL
// create adapter
val adapter = ViewPagerFragmentAdapter(
this,
RankingsFriendsFragment(get()),
RankingsGroupsFragment(),
RankingsWorldFragment(get()),
RankingsFriendsFragment(get())
)
viewPager!!.adapter = adapter
TabLayoutMediator(tabLayout!!, viewPager!!) { tab, position ->
tab.text = tabTitles[position]
}.attach()
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/ChallengesReceivedFragment.kt | 3191011123 | package com.jolufeja.tudas
import android.os.Bundle
import android.util.Log
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentTransaction
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
import arrow.core.computations.either
import arrow.core.identity
import com.jolufeja.httpclient.error.CommonErrors
import com.jolufeja.tudas.adapters.RecycleViewAdapter
import com.jolufeja.tudas.data.ChallengesItem
import com.jolufeja.tudas.data.HeaderItem
import com.jolufeja.tudas.data.ListItem
import com.jolufeja.tudas.service.challenges.ChallengeService
import kotlinx.coroutines.flow.collect
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.launch
import org.koin.android.ext.android.get
class ChallengesReceivedFragment(
private val challengeService: ChallengeService
) : Fragment(R.layout.fragment_challenges_received) {
private var mRecyclerView: RecyclerView? = null
private var mAdapter: RecyclerView.Adapter<*>? = null
private var listOfChallenges: ArrayList<ChallengesItem> = ArrayList()
private var finalList: MutableList<ListItem> = mutableListOf()
private suspend fun buildChallengeList() = flow<List<ListItem>> {
either<CommonErrors, Unit> {
emit(emptyList())
val openChallenges = challengeService
.getOpenChallenges()
.bind()
.toChallengeListItems()
val completedChallenges = challengeService
.getFinishedChallenges()
.bind()
.toChallengeListItems()
val combined = listOf(HeaderItem("Open Challenges")) + openChallenges +
listOf(HeaderItem("Completed")) + completedChallenges
emit(combined)
}.fold(
ifLeft = { emit(emptyList()) },
ifRight = ::identity
)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
val refreshLayout = view.findViewById<SwipeRefreshLayout>(R.id.received_swiperefresh)
refreshLayout?.setOnRefreshListener {
lifecycleScope.launch {
buildChallengeList().collect { challenges ->
refreshLayout.isRefreshing = false
finalList = challenges.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(challenges)
mAdapter?.notifyDataSetChanged()
}
}
}
mRecyclerView = view.findViewById(R.id.challenges_received_recycler_view)
var mLayoutManager = LinearLayoutManager(context, LinearLayoutManager.VERTICAL, false)
mRecyclerView!!.layoutManager = mLayoutManager
// Add Adapter so cards will be displayed
mAdapter = context?.let {
RecycleViewAdapter(
it,
finalList,
R.layout.card_challenges_received,
R.layout.card_header,
0,
0,
0,
0,
0
) { item ->
// Open New Fragment
val challengeArgs = Bundle().also { bundle ->
bundle.putSerializable(CHALLENGE_KEY, (item as ChallengesItem).challenge)
}
val individualChallengeReceivedFragment = IndividualChallengeReceivedFragment(get())
individualChallengeReceivedFragment.arguments = challengeArgs
val transaction: FragmentTransaction =
requireActivity().supportFragmentManager.beginTransaction()
transaction.replace(
((view as ViewGroup).parent as View).id,
individualChallengeReceivedFragment
)
transaction.addToBackStack("challenge_received_info")
transaction.commit()
item.id.let { Log.d("TAG", it.toString()) }
}
}
mRecyclerView!!.adapter = mAdapter
lifecycleScope.launch {
buildChallengeList().collect { challenges ->
finalList = challenges.toMutableList()
(mAdapter as? RecycleViewAdapter)?.refreshData(challenges)
mAdapter?.notifyDataSetChanged()
}
}
}
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/service/challenges/Challenge.kt | 3394380654 | package com.jolufeja.tudas.service.challenges
import com.fasterxml.jackson.annotation.JsonIgnoreProperties
import java.io.Serializable
import java.time.LocalDate
import java.util.*
@JsonIgnoreProperties(ignoreUnknown = true)
data class Challenge(
val id: Int? = null,
val name: String,
val creator: String,
val creationDate: LocalDate,
val description: String,
val dueDate: Date,
val reward: String,
val worth: Int,
val addressedTo: String
) : Serializable |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/service/challenges/InitialChallenge.kt | 3673580008 | package com.jolufeja.tudas.service.challenges
import java.util.*
data class InitialChallenge(
val challengeName: String,
val creatorName: String,
val description: String,
val dueDate: Date,
val reward: String,
val addressedTo: String,
val worth: Int,
) |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/service/challenges/ChallengeService.kt | 3055005834 | package com.jolufeja.tudas.service.challenges
import android.content.Context
import android.graphics.Bitmap
import android.os.Environment
import android.provider.MediaStore
import arrow.core.Either
import arrow.core.flatMap
import com.jolufeja.authentication.UserAuthenticationService
import com.jolufeja.httpclient.*
import com.jolufeja.httpclient.error.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.RequestBody
import okhttp3.RequestBody.Companion.asRequestBody
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.ByteArrayOutputStream
import java.io.File
import java.text.SimpleDateFormat
import java.util.*
sealed interface ProofKind {
interface Body
fun buildJsonBody(challenge: Challenge, userName: String): Body
data class ProofImage(val image: File) : ProofKind {
data class WithImageBody(
val challengeName: String,
val userName: String
) : Body
override fun buildJsonBody(challenge: Challenge, userName: String) =
WithImageBody(challenge.name, userName)
fun contentToRequestBody(challenge: Challenge, userName: String) = MultipartBody.Builder()
.setType(MultipartBody.FORM)
.addFormDataPart("file",image.name, image.asRequestBody("image/jpeg".toMediaType()))
.addFormDataPart("challengeName", challenge.name)
.addFormDataPart("userName", userName)
.build()
}
data class SocialMediaLink(val link: String) : ProofKind {
data class WithLinkBody(
val challengeName: String,
val userName: String,
val url: String
) : Body
override fun buildJsonBody(challenge: Challenge, userName: String) =
WithLinkBody(challenge.name, userName, link)
}
}
interface ChallengeService {
suspend fun createChallenge(challenge: InitialChallenge): Either<CommonErrors, Unit>
suspend fun getChallenge(name: String): Either<CommonErrors, Challenge?>
suspend fun getPublicChallenges(): Either<CommonErrors, List<Challenge>>
suspend fun getFriendChallenges(): Either<CommonErrors, List<Challenge>>
suspend fun getOwnCreatedChallenges(): Either<CommonErrors, List<Challenge>>
suspend fun getFinishedChallenges(): Either<CommonErrors, List<Challenge>>
suspend fun getOpenChallenges(): Either<CommonErrors, List<Challenge>>
suspend fun finishChallengeWithProof(
challenge: Challenge,
proofKind: ProofKind
): Either<CommonErrors, Unit>
}
data class UserName(val userName: String)
data class ChallengeName(val challengeName: String)
class DefaultChallengeService(
private val httpClient: HttpClient,
private val authenticationService: UserAuthenticationService
) : ChallengeService {
override suspend fun createChallenge(
challenge: InitialChallenge
): Either<CommonErrors, Unit> =
httpClient.post("challenge/addchallenge")
.jsonBody(challenge)
.tryExecute()
.void()
override suspend fun getChallenge(
name: String
): Either<CommonErrors, Challenge?> =
httpClient.post("challenge/getchallenge")
.jsonBody(ChallengeName(name))
.tryExecute()
.awaitJsonBodyOrNull()
override suspend fun getPublicChallenges(): Either<CommonErrors, List<Challenge>> =
httpClient.get("challenge/getpublicchallenges")
.tryExecute()
.awaitJsonBody(jsonListOf<Challenge>())
override suspend fun getFriendChallenges(): Either<CommonErrors, List<Challenge>> =
httpClient.post("challenge/getchallengesfromfriends")
.jsonBodyOfCurrentUser()
.tryExecute()
.awaitJsonBody(jsonListOf<Challenge>())
override suspend fun getOwnCreatedChallenges(): Either<CommonErrors, List<Challenge>> =
httpClient.post("user/getcreatedchallenges")
.jsonBodyOfCurrentUser()
.tryExecute()
.awaitJsonBody(jsonListOf<Challenge>())
override suspend fun getFinishedChallenges(): Either<CommonErrors, List<Challenge>> =
httpClient.post("user/getfinishedchallenges")
.jsonBodyOfCurrentUser()
.tryExecute()
.awaitJsonBody(jsonListOf<Challenge>())
override suspend fun getOpenChallenges(): Either<CommonErrors, List<Challenge>> =
httpClient.post("user/getopenchallenges")
.jsonBodyOfCurrentUser()
.tryExecute()
.awaitJsonBody(jsonListOf<Challenge>())
override suspend fun finishChallengeWithProof(
challenge: Challenge,
proofKind: ProofKind
): Either<CommonErrors, Unit> {
val userName = authenticationService.authentication.await().user.name
return when (proofKind) {
is ProofKind.ProofImage -> {
val body = proofKind.contentToRequestBody(challenge, userName)
httpClient.post("challenge/uploadPicture")
.body(body)
.tryExecute()
.void()
}
is ProofKind.SocialMediaLink -> {
httpClient.post("challenge/uploadsocialmedia")
.jsonBody(proofKind.buildJsonBody(challenge, userName))
.tryExecute()
.void()
}
}
}
private suspend fun HttpClientRequest.Builder.jsonBodyOfCurrentUser() =
jsonBody(UserName(authenticationService.authentication.await().user.name))
private fun HttpClientRequest.Builder.emptyBody(): HttpClientRequest.Builder =
jsonBody("")
}
suspend fun <T : Any> Either<CommonErrors, HttpClientResponse>.awaitJsonBody(
payloadType: JsonTypeSupplier<T>
): Either<CommonErrors, T> =
flatMap { response -> catchError { response.awaitJsonBody(payloadType) } }
fun Bitmap.asByteArray(): ByteArray {
val ostream = ByteArrayOutputStream()
this.compress(Bitmap.CompressFormat.JPEG,100,ostream)
return ostream.toByteArray()
} |
tudas-app/tudas-app/app/src/main/java/com/jolufeja/tudas/service/user/User.kt | 3025403561 | package com.jolufeja.tudas.service.user
import com.jolufeja.tudas.service.challenges.Challenge
data class User(
val name: String,
val password: String,
val emailAddress: String,
val profilePicture: String,
val points: Int,
val friends: List<FriendEntry>,
val createdChallenges: List<Challenge>,
val openChallenges: List<Challenge>,
val finishedChallenges: List<Challenge>
) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.