Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.controller;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;
import com.spice.profitmandi.dao.entity.inventory.State;
import com.spice.profitmandi.dao.entity.inventory.Warehouse;
import com.spice.profitmandi.dao.entity.transaction.Seller;
import com.spice.profitmandi.dao.entity.transaction.WarehouseAddressMaster;
import com.spice.profitmandi.dao.enumuration.warehouse.WarehouseStatus;
import com.spice.profitmandi.dao.model.warehouse.NewPhysicalWarehouseRequest;
import com.spice.profitmandi.dao.model.warehouse.NewSellerRequest;
import com.spice.profitmandi.dao.model.warehouse.NewWarehouseAddressRequest;
import com.spice.profitmandi.dao.model.warehouse.PhysicalWarehouseView;
import com.spice.profitmandi.dao.repository.inventory.StateRepository;
import com.spice.profitmandi.dao.repository.transaction.SellerRepository;
import com.spice.profitmandi.dao.repository.transaction.SellerWarehouseRepository;
import com.spice.profitmandi.service.SellerService;
import com.spice.profitmandi.service.warehouse.SuspendedWarehouseStockAlertService;
import com.spice.profitmandi.service.warehouse.WarehouseSetupService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Seller / physical warehouse setup screen, including each warehouse's status (active / suspended / inactive) and label. Rules live in WarehouseSetupService; this only maps requests to it.
 */
@Controller
@Transactional(rollbackFor = Throwable.class)
public class SellerController {

    @Autowired
    private SellerRepository sellerRepository;

    @Autowired
    private StateRepository stateRepository;

    @Autowired
    private SellerWarehouseRepository sellerWarehouseRepository;

    @Autowired
    private SellerService sellerService;

    @Autowired
    private WarehouseSetupService warehouseSetupService;

    @Autowired
    private SuspendedWarehouseStockAlertService suspendedWarehouseStockAlertService;

    private static final Logger LOGGER = LogManager.getLogger(SellerController.class);

    /**
     * Realign the INTERNAL stores of a warehouse with the address currently mapped to it.
     *
     * The mapping had no edit screen - it got repointed straight in the database - so nothing
     * carried a warehouse's move through to the internal store's user.address, and orders kept
     * billing to an address the branch had left years earlier. Remapping from the setup screen now
     * syncs on its own; this stays for mappings changed outside it.
     */
    @RequestMapping(value = "/syncWarehouseInternalAddress", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> syncWarehouseInternalAddress(@RequestParam(name = "warehouseId") int warehouseId)
            throws Exception {
        int synced = sellerService.syncInternalStoreAddresses(warehouseId);
        LOGGER.info("Synced {} internal store address(es) for warehouse {}", synced, warehouseId);
        Map<String, Object> response = new HashMap<>();
        response.put("warehouseId", warehouseId);
        response.put("storesSynced", synced);
        return ResponseEntity.ok(response);
    }

    @RequestMapping(value = "/getAllSeller", method = RequestMethod.GET)
    public String getAllSeller(Model model) throws Exception {
        Map<Integer, Long> warehouseCounts = sellerWarehouseRepository.selectAll().stream()
                .collect(Collectors.groupingBy(x -> x.getSellerId(), Collectors.counting()));
        List<PhysicalWarehouseView> warehouses = warehouseSetupService.getAllPhysicalWarehouses();
        Map<WarehouseStatus, Long> statusCounts = new EnumMap<>(WarehouseStatus.class);
        for (WarehouseStatus status : WarehouseStatus.values()) {
            statusCounts.put(status, warehouses.stream().filter(x -> x.getStatus() == status).count());
        }
        model.addAttribute("warehouses", warehouses);
        model.addAttribute("statusCounts", statusCounts);
        model.addAttribute("statuses", WarehouseStatus.values());
        model.addAttribute("sellers", warehouseSetupService.getSellers());
        model.addAttribute("warehouseCounts", warehouseCounts);
        model.addAttribute("stateNames", this.stateNames());
        model.addAttribute("states", stateRepository.selectAll());
        model.addAttribute("addresses", warehouseSetupService.getAddresses());
        return "seller";
    }

    @RequestMapping(value = "/getSellerWareHouse", method = RequestMethod.GET)
    public String getSellerWareHouse(@RequestParam(name = "sellerId") int sellerId, Model model) throws Exception {
        Seller seller = sellerRepository.selectById(sellerId);
        model.addAttribute("seller", seller);
        model.addAttribute("stateNames", this.stateNames());
        model.addAttribute("warehouses", warehouseSetupService.getPhysicalWarehouses(sellerId));
        model.addAttribute("statuses", WarehouseStatus.values());
        model.addAttribute("assignableAddresses", warehouseSetupService.getAssignableAddresses(seller.getStateId()));
        return "seller-warehouse-container";
    }

    @RequestMapping(value = "/createNewAddress", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> createNewAddress(@RequestBody NewWarehouseAddressRequest request) throws Exception {
        WarehouseAddressMaster address = warehouseSetupService.createAddress(request);
        return ResponseEntity.ok(this.idResponse("addressId", address.getId()));
    }

    @RequestMapping(value = "/warehouseAddress/{addressId}/active", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> setAddressActive(@PathVariable int addressId, @RequestParam boolean active)
            throws Exception {
        warehouseSetupService.setAddressActive(addressId, active);
        return ResponseEntity.ok(this.idResponse("addressId", addressId));
    }

    @RequestMapping(value = "/createNewSeller", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> createNewSeller(@RequestBody NewSellerRequest request) throws Exception {
        Seller seller = warehouseSetupService.createSeller(request);
        return ResponseEntity.ok(this.idResponse("sellerId", seller.getId()));
    }

    @RequestMapping(value = "/createNewWarehouse", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> createNewWarehouse(@RequestBody NewPhysicalWarehouseRequest request) throws Exception {
        Warehouse warehouse = warehouseSetupService.createPhysicalWarehouse(request);
        return ResponseEntity.ok(this.idResponse("warehouseId", warehouse.getId()));
    }

    @RequestMapping(value = "/physicalWarehouse/{warehouseId}/status", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> setWarehouseStatus(@PathVariable int warehouseId, @RequestParam WarehouseStatus status)
            throws Exception {
        warehouseSetupService.setWarehouseStatus(warehouseId, status);
        return ResponseEntity.ok(this.idResponse("warehouseId", warehouseId));
    }

    @RequestMapping(value = "/physicalWarehouse/{warehouseId}/displayName", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> setWarehouseDisplayName(@PathVariable int warehouseId, @RequestParam String displayName)
            throws Exception {
        warehouseSetupService.setWarehouseDisplayName(warehouseId, displayName);
        return ResponseEntity.ok(this.idResponse("warehouseId", warehouseId));
    }

    // Same mail the daily cron sends; from the screen it goes out at once.
    @RequestMapping(value = "/warehouseStockAlert/send", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> sendWarehouseStockAlert() throws Exception {
        Map<String, Object> response = new HashMap<>();
        response.put("summary", suspendedWarehouseStockAlertService.sendAlert());
        return ResponseEntity.ok(response);
    }

    @RequestMapping(value = "/physicalWarehouse/{warehouseId}/address", method = RequestMethod.POST)
    @ResponseBody
    public ResponseEntity<?> remapAddress(@PathVariable int warehouseId, @RequestParam int addressId)
            throws Exception {
        warehouseSetupService.remapAddress(warehouseId, addressId);
        return ResponseEntity.ok(this.idResponse("warehouseId", warehouseId));
    }

    // Raised after the transaction has rolled back; the screen shows the rule that was broken.
    @ExceptionHandler(ProfitMandiBusinessException.class)
    @ResponseBody
    public ResponseEntity<String> handleBusinessException(ProfitMandiBusinessException e) {
        LOGGER.info("Seller setup refused: {} = {} - {}", e.getRejectedType(), e.getRejectedValue(), e.getCode());
        return ResponseEntity.badRequest().body(e.getCode());
    }

    private Map<Integer, String> stateNames() {
        return stateRepository.selectAll().stream()
                .collect(Collectors.toMap(State::getId, State::getName, (a, b) -> a));
    }

    private Map<String, Object> idResponse(String key, int id) {
        Map<String, Object> response = new HashMap<>();
        response.put(key, id);
        return response;
    }
}