Untitled

 avatar
unknown
plain_text
3 years ago
18 kB
5
Indexable
class FilteredAssetsFragment : BaseFragment(R.layout.fragent_view_all_assets),
    DialogScanMode.ItemClickListener,
    DialogUpdateBuildingAndRoom.ItemClickListener, DialogVerifyStatus.ItemClickListener,
    FilteredSubListingAdapter.ItemClickListener {

    private var finalPosition: Int = -1
    private val assetsViewListingAdapter: FilteredAssetsViewListingAdapter by lazy {
        FilteredAssetsViewListingAdapter(
            requireActivity(),
            this, filteredBuildingsWithAssets
        )
    }

    private lateinit var listAllAssetsData: List<ExeclImportTable>
    private val assetListData: List<AssetDataObject> by argument(ARG_ASSETS_LIST_DATA)
    private lateinit var dao: DaoAccess

    private lateinit var layoutManager: LinearLayoutManager
    private lateinit var listAllBuildingData: List<BuildingDataObject>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        dao = AgentDatabase.getInstance(activity).daoAccess()

    }


    private lateinit var agentDatabase: AgentDatabase

    private lateinit var listRoomData: List<RoomDataObject>
    private lateinit var filteredRoomsWithAssets: FilteredRoomsOject
    private var filteredBuildingsWithAssets: ArrayList<FilteredBuildings> = ArrayList()
    var buildingId: String? = ""
    var buildingName: String? = ""
    private lateinit var buildingObj: BuildingDataObject
    private var buildingPosition = -1
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        agentDatabase = AgentDatabase.getInstance(activity)
        dao.makeNullItems()
        assetListData.mapIndexed { index, syncRowX ->
            buildingId = syncRowX.originalBuildingId.toString()
            /*Log.e(
                "buildingiD",
                "" + buildingId
            )*/
            Log.e(
                "assetListData ROOK ID", "" + assetListData[index].originalRoomId
            )
        }



        rl_menuitem.setOnClickListener {
            rl_menuitem.visibility = View.GONE
        }

        if (assetListData.isEmpty()) {
            rv_assets_listing.isVisible = false
            tv_no_assets_found.isVisible = true
        } else {
            rv_assets_listing.isVisible = true
            tv_no_assets_found.isVisible = false
        }
        tv_action_continue.isVisible = false
        layoutManager = LinearLayoutManager(activity, LinearLayoutManager.VERTICAL, false)
        rv_assets_listing.layoutManager = layoutManager
        AppExecutors.getInstance().diskIO()
            .execute {

                try {
                    listAllBuildingData =
                        agentDatabase.daoAccess().getAllBuildingData()


                    listAllBuildingData.mapIndexed { POSITION, data ->
                        /*Log.e(
                            "listAllBuildingData",
                            "" + data.buildingId + "   " + buildingId
                        )*/
                        if (data.buildingId == buildingId) {
                            Log.e(
                                "listAllBuildingData",
                                "" + data.buildingId + "   " + buildingId
                            )
                            //buildingName = syncRow.data.buildingName
                            buildingPosition = POSITION
                            buildingObj = data
                        }
                    }





                    try {
                        listRoomData = agentDatabase.daoAccess().getAllRoomsData()
                    } catch (e: Exception) {
                        Log.e("Exception", "" + e.printStackTrace())
                    }
                    listRoomData.mapIndexed { roomPosition, roomDataObject ->
                        var isRoomFound = false
                        val filteredAssets: ArrayList<AssetDataObject> = ArrayList()
                        assetListData.mapIndexed { _, syncRowX ->

                            if (syncRowX.updatedRoomId != null) {
                                if (syncRowX.updatedRoomId == roomDataObject.roomId) {
                                    isRoomFound = true
                                    filteredAssets.add(syncRowX)
                                    Log.e(
                                        "rooms",
                                        "" + syncRowX
                                    )
                                }
                            }
                        }
                        if (isRoomFound) {
                            filteredRoomsWithAssets = FilteredRoomsOject(
                                roomDataObject
                            )
                            filteredBuildingsWithAssets.add(
                                FilteredBuildings(
                                    buildingObj,
                                    filteredRoomsWithAssets,
                                    filteredAssets,
                                    buildingPosition,
                                    roomPosition
                                )
                            )
                        }
                    }

                    Log.e(
                        "all data",
                        "" + filteredBuildingsWithAssets.size
                    )


                    activity?.runOnUiThread {
                        if (filteredBuildingsWithAssets.isNotEmpty()) {

                            rv_assets_listing.isVisible = true
                            tv_no_assets_found.isVisible = false
                            // tv_action_continue.isVisible = true
                            rv_assets_listing.adapter = assetsViewListingAdapter
                        } else {
                            tv_no_assets_found.isVisible = true
                            rv_assets_listing.isVisible = false
                            // tv_action_continue.isVisible = false
                        }
                        // progressBar.isVisible = false
                    }

                } catch (e: Exception) {
                    Log.e("Exception", "" + e.printStackTrace())
                }


            }


        rl_more.setOnClickListener(listener)
        iv_back.setOnClickListener(listener)
        tv_action_continue.setOnClickListener(listener)
        included.tv_verify_menu.setOnClickListener(listener)
        included.tv_update_building_room_menu.setOnClickListener(listener)
        included.tv_export_menu.setOnClickListener(listener)
        included.tv_add_assets_menu.setOnClickListener(listener)
        included.tv_edit_filter_menu.setOnClickListener(listener)
        included.tv_scan_mode_menu.setOnClickListener(listener)
        included.tv_change_status_menu.setOnClickListener(listener)
        included.tv_assets_summary_menu.setOnClickListener(listener)
        included.tv_update_room_status_menu.setOnClickListener(listener)
    }

    private val listener = View.OnClickListener { view ->
        when (view.id) {
            R.id.tv_verify_menu -> {
                if (finalPosition > -1) {
                    val dialogVerifyStatus =
                        DialogVerifyStatus.newInstance(
                            this,
                            latestBuildingPos,
                            latestRoomPos,
                            assetListData,
                            finalPosition,
                            latestBuildingObj,
                            latestRoomObj,
                            STATE_VERIFY
                        )
                    dialogVerifyStatus.show(childFragmentManager, "CustomDialog")
                    rl_menuitem.visibility = View.GONE
                } else {
                    Utils.showToastForFragments(
                        requireActivity(),
                        "Please select atleast one asset"
                    )
                }
            }
            R.id.tv_update_building_room_menu -> {
                if (finalPosition > -1) {
                    var dialog = DialogUpdateBuildingAndRoom.newInstance(
                        this,
                        latestBuildingPos,
                        latestRoomPos,
                        assetListData,
                        finalPosition,
                        latestBuildingObj,
                        latestRoomObj
                    ).show(childFragmentManager, "CustomDialog")

                    rl_menuitem.visibility = View.GONE
                } else {
                    Utils.showToastForFragments(
                        requireActivity(),
                        "Please select atleast one asset"
                    )
                }
            }
            R.id.tv_export_menu -> {
                listAllAssetsData = agentDatabase.daoAccess().getExcelData()
                if (listAllAssetsData.isNullOrEmpty()) {
                    Utils.showToastForFragments(
                        requireActivity(),
                        getString(R.string.please_select_atleast_one_asset)
                    )
                } else {
                    val customDialogFragment = CustomDialogFragment()
                    customDialogFragment.isCancelable = false
                    customDialogFragment.show(requireActivity().supportFragmentManager, "dialog")
                    rl_menuitem.visibility = View.GONE
                }
            }
            R.id.tv_add_assets_menu -> {
                val intent = Intent(activity, CreateAssetsScreenActivity::class.java)
                startActivity(intent)
                rl_menuitem.visibility = View.GONE
            }
            R.id.tv_edit_filter_menu -> {}
            R.id.tv_scan_mode_menu -> {}
            R.id.tv_change_status_menu -> {
                if (finalPosition > -1) {
                    val dialogVerifyStatus =
                        DialogVerifyStatus.newInstance(
                            this,
                            latestBuildingPos,
                            latestRoomPos,
                            assetListData,
                            finalPosition,
                            latestBuildingObj,
                            latestRoomObj,
                            STATE_CHANGE
                        )
                    dialogVerifyStatus.show(childFragmentManager, "CustomDialog")
                    rl_menuitem.visibility = View.GONE
                } else {
                    Utils.showToastForFragments(
                        requireActivity(),
                        "Please select atleast one asset"
                    )
                }
            }
            R.id.tv_assets_summary_menu -> {
                parentFragmentManager?.doTransaction {
                    add(
                        R.id.fl_dashboard,
                        AssetsSummaryFragment.newInstance()
                    )
                }
                rl_menuitem.visibility = View.GONE
            }
            R.id.tv_update_room_status_menu -> {
                parentFragmentManager?.doTransaction {
                    add(
                        R.id.fl_dashboard,
                        AssetsRoomStatusListingFragment.newInstance()
                    )
                }
                rl_menuitem.visibility = View.GONE
            }
            R.id.rl_more -> {
                if (rl_menuitem.isVisible) {
                    rl_menuitem.visibility = View.GONE
                } else {
                    rl_menuitem.visibility = View.VISIBLE
                }
            }
            R.id.iv_back -> {
                parentFragmentManager.popBackStack()
            }
            R.id.tv_action_continue -> {
                var dialog = DialogScanMode.newInstance(
                    this
                ).show(childFragmentManager, "CustomDialog")
            }
        }
    }


    fun FragmentManager.doTransaction(
        func: FragmentTransaction.() ->
        FragmentTransaction
    ) {
        beginTransaction().func().addToBackStack(null).commit()
    }

    override fun onViewDetailsClick(
        position: Int,
        name: String,
        assetDataObject: AssetDataObject,
        assets: ArrayList<AssetDataObject>
    ) {
        var mFinalVal: String = ""
        AppExecutors.getInstance().diskIO()
            .execute {
                try {
                    val originalBuildingDataObject =
                        dao.getBuildingName(assetDataObject.updatedBuildingId.toString())

                    val originalRoomDataObject =
                        dao.getRoomData(assetDataObject.updatedRoomId.toString())
                    mFinalVal =
                        originalBuildingDataObject.buildingName + "  " + originalRoomDataObject.roomNumber

                    activity?.runOnUiThread {
                        parentFragmentManager?.doTransaction {
                            add(
                                R.id.fl_dashboard,
                                AssetsViewFragment.newInstance(
                                    mFinalVal,
                                    assetDataObject,
                                    assets
                                )
                            )
                        }
                    }

                } catch (e: Exception) {
                    e.printStackTrace()

                }
            }


    }

    lateinit var latestBuildingObj: BuildingDataObject
    lateinit var latestRoomObj: RoomDataObject
    var latestBuildingPos: Int = -1
    var latestRoomPos: Int = -1

    override fun onCheckBoxClick(
        position: Int,
        buildingObj: BuildingDataObject,
        roomObj: FilteredRoomsOject,
        buildingPosition: Int,
        roomPosition: Int,
        shouldRefresh: Boolean
    ) {

        finalPosition = position
        latestBuildingObj = buildingObj
        latestRoomObj = roomObj.filteredRoomObject
        latestBuildingPos = buildingPosition
        latestRoomPos = roomPosition
        if (shouldRefresh) {
            filteredBuildingsWithAssets.mapIndexed { index, filteredBuildings ->
                if (index != latestBuildingPos) {
                    //filteredBuildings.isExpended = false
                    filteredBuildings.assets.mapIndexed { _, assetDataObject ->
                        if (assetDataObject.isSelected != null) {
                            assetDataObject.isSelected = null
                        }
                    }
                }
            }

            assetsViewListingAdapter.notifyDataSetChanged()
        }


    }


    override fun onScannerViaRFIDClick() {
        parentFragmentManager?.doTransaction {
            add(
                R.id.fl_scanner,
                ScannerModeFragment.newInstance()
            )
        }

    }

    override fun onBarCodeClick() {
        val intent = Intent(activity, ScannerSelfAssignmentActivity::class.java)
        startActivity(intent)
    }

    override fun onPhoneScannerClick() {
        val intent = Intent(activity, ScannerSelfAssignmentActivity::class.java)
        startActivity(intent)
    }

    companion object {

        private const val ARG_ASSETS_LIST_DATA = "assetData"


        fun newInstance(
            arrayList: List<AssetDataObject>
        ) =
            FilteredAssetsFragment().apply {
                arguments = bundleOf(
                    ARG_ASSETS_LIST_DATA to arrayList
                )
            }
    }

    override fun onCancel() {
    }

    override fun onSave(
        buildingDataObj: BuildingDataObject,
        roomDataObj: RoomDataObject,
        assetListData: List<AssetDataObject>
    ) {

    }


    private lateinit var dataList: List<AssetDataObject>
    /* override fun onSave(
         buildingDataObj: BuildingDataObject,
         roomDataObj: RoomDataObject,
         assetListData: List<AssetDataObject>
     ) {
         activity?.runOnUiThread {
             progressBar.isVisible = true
         }
         Log.d("building_obj", "" + buildingDataObj + " " + roomDataObj + " " + assetListData.size)
         AppExecutors.getInstance().diskIO()
             .execute {
                 try {

                     dataList = AgentDatabase.getInstance(activity).daoAccess()
                         .getAssetAccordingToBuildingAndRoom(
                             "%" + buildingDataObj.buildingId + "%",
                             "%" + roomDataObj.roomId.toString() + "%"
                         )
                     Log.d("dataList", "dataList" + dataList.size)
                     activity?.runOnUiThread {
                         progressBar.isVisible = false
                         if (!dataList.isNullOrEmpty()) {
                             rv_assets_listing.isVisible = true
                             tv_no_assets_found.isVisible = false
                             tv_action_continue.isVisible = true

                             assetsViewListingAdapter = FilteredAssetsViewListingAdapter(
                                 requireActivity(),
                                 this, filteredBuildingsWithAssets
                             )
                             rv_assets_listing.adapter = assetsViewListingAdapter
                         } else {
                             rv_assets_listing.isVisible = false
                             tv_no_assets_found.isVisible = true
                             // tv_action_continue.isVisible = false
                         }

                     }
                 } catch (e: Exception) {
                     e.printStackTrace()

                 }
             }


     }*/


    override fun onResume() {
        super.onResume()


    }

    override fun onCancelClick() {

    }

    override fun onVerifyClick() {

    }

}
Editor is loading...