diff --git a/backend/src/main/java/com/realnet/Builders/Repos/BuilderRepository.java b/backend/src/main/java/com/realnet/Builders/Repos/BuilderRepository.java index 16eb1a1..d7c2c44 100644 --- a/backend/src/main/java/com/realnet/Builders/Repos/BuilderRepository.java +++ b/backend/src/main/java/com/realnet/Builders/Repos/BuilderRepository.java @@ -9,7 +9,7 @@ import com.realnet.Builders.Entity.Builder_entity_t; @Repository public interface BuilderRepository extends JpaRepository { - @Query(value = "select * from builder_entity_t where job_name= ?1 && job_type=?2", nativeQuery = true) + @Query(value = "select * from builder_entity_t where job_name= ?1 AND job_type=?2", nativeQuery = true) Builder_entity_t findByjobTypeAndName(String job_name, String job_type); } diff --git a/backend/src/main/java/com/realnet/Builders/Services/SqlDumpExecutor.java b/backend/src/main/java/com/realnet/Builders/Services/SqlDumpExecutor.java new file mode 100644 index 0000000..c9f2cba --- /dev/null +++ b/backend/src/main/java/com/realnet/Builders/Services/SqlDumpExecutor.java @@ -0,0 +1,130 @@ +package com.realnet.Builders.Services; + +import java.sql.Connection; +import java.sql.SQLException; +import java.sql.Statement; + +import org.springframework.stereotype.Service; + +@Service +public class SqlDumpExecutor { + + /** + * Executes a massive SQL dump safely. + * + * @param connection JDBC connection + * @param sqlDump Full SQL dump string from getSql() + */ + public void executeDump(Connection connection, String sqlDump) { + Statement stmt = null; + try { + stmt = connection.createStatement(); + connection.setAutoCommit(false); + + // Remove MySQL backticks + sqlDump = sqlDump.replaceAll("`", ""); + + // Remove table-level DEFAULT COLLATE or CHARSET + sqlDump = sqlDump.replaceAll("(?i)DEFAULT\\s+CHARSET=[^;\\n]+", ""); + sqlDump = sqlDump.replaceAll("(?i)COLLATE=[^;\\n]+", ""); + + // Convert data types + sqlDump = sqlDump.replaceAll("(?i)bigint", "INTEGER"); + sqlDump = sqlDump.replaceAll("(?i)int\\([0-9]+\\)", "INTEGER"); + sqlDump = sqlDump.replaceAll("(?i)varchar\\([0-9]+\\)", "TEXT"); + sqlDump = sqlDump.replaceAll("(?i)bit\\([0-9]+\\)", "INTEGER"); + sqlDump = sqlDump.replaceAll("(?i)longblob", "BLOB"); + + // Remove AUTO_INCREMENT (if any) + sqlDump = sqlDump.replaceAll("(?i)AUTO_INCREMENT", ""); + + // Remove MySQL-specific directives + sqlDump = sqlDump.replaceAll("(?i)SET\\s+[^;]+;", ""); + sqlDump = sqlDump.replaceAll("(?i)ENGINE=\\w+\\s*", ""); + sqlDump = sqlDump.replaceAll("(?i)AUTO_INCREMENT=\\d+", ""); + sqlDump = sqlDump.replaceAll("(?i)CHARSET=\\w+", ""); + + // Remove DEFAULT NULL (SQLite allows NULL by default) + sqlDump = sqlDump.replaceAll("(?i)DEFAULT NULL", ""); + + // Convert UNIQUE KEY to UNIQUE + sqlDump = sqlDump.replaceAll("(?i)UNIQUE KEY [^\\(]+\\(", "UNIQUE("); + + // Remove double commas in CREATE TABLE (,,) + sqlDump = sqlDump.replaceAll(",\\s*,", ","); + + // Remove _binary prefix in INSERT statements + sqlDump = sqlDump.replaceAll("(?i)_binary\\s+'", "'"); + + String delimiter = ";"; // default delimiter + StringBuilder sqlStatement = new StringBuilder(); + + String[] lines = sqlDump.split("\\r?\\n"); + for (String line : lines) { + line = line.trim(); + + // Skip empty lines and comments + if (line.isEmpty() || line.startsWith("--") || line.startsWith("//") || line.startsWith("/*")) { + continue; + } + + // Detect DELIMITER changes (optional, mostly MySQL) + if (line.startsWith("DELIMITER ")) { + delimiter = line.substring("DELIMITER ".length()).trim(); + continue; + } + + // Remove MySQL-specific comments like /*! ... */ + line = line.replaceAll("/\\*!.*?\\*/", "").trim(); + if (line.isEmpty()) + continue; + + sqlStatement.append(line).append(" "); + + // Check if statement ends with current delimiter + if (sqlStatement.toString().trim().endsWith(delimiter)) { + String finalSql = sqlStatement.toString().trim(); + + // Remove the delimiter from the end + if (delimiter.length() > 0 && finalSql.endsWith(delimiter)) { + finalSql = finalSql.substring(0, finalSql.length() - delimiter.length()).trim(); + } + + try { + stmt.execute(finalSql); + } catch (SQLException e) { + System.err.println("Failed SQL: " + finalSql); + e.printStackTrace(); + } + + sqlStatement.setLength(0); // reset for next statement + } + } + + connection.commit(); + + } catch (Exception e) { + System.err.println("Error executing SQL dump: " + e.getMessage()); + e.printStackTrace(); + try { + connection.rollback(); + } catch (SQLException ex) { + System.err.println("Rollback failed: " + ex.getMessage()); + } + } finally { + if (stmt != null) { + try { + stmt.close(); + } catch (SQLException e) { + e.printStackTrace(); + } + } + try { + connection.setAutoCommit(true); + } catch (SQLException e) { + e.printStackTrace(); + } + } + } + +} diff --git a/backend/src/main/java/com/realnet/SureConnect/Controller/SureController.java b/backend/src/main/java/com/realnet/SureConnect/Controller/SureController.java new file mode 100644 index 0000000..94d3347 --- /dev/null +++ b/backend/src/main/java/com/realnet/SureConnect/Controller/SureController.java @@ -0,0 +1,73 @@ +package com.realnet.SureConnect.Controller; + +import java.util.List; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RestController; +import com.realnet.SureConnect.Entities.Sure_Connect; +import com.realnet.SureConnect.Service.SureService; + +@RestController +public class SureController { + + @Autowired + private SureService sureService; + +// CREATE DATA + @PostMapping("/Sure_Connect") + public ResponseEntity add(@RequestBody Sure_Connect sure_Connect) { + Sure_Connect order = sureService.create(sure_Connect); + + return new ResponseEntity<>(order, HttpStatus.OK); + + } + +// update data + @PutMapping("/Sure_Connect/{id}") + public ResponseEntity update(@RequestBody Sure_Connect sure_Connect, @PathVariable Integer id) { + + Sure_Connect order = sureService.update(sure_Connect, id); + + return new ResponseEntity<>(order, HttpStatus.OK); + } + +// Get all + @GetMapping("/Sure_Connect") + public ResponseEntity getall() { + List pm = sureService.getall(); + return new ResponseEntity<>(pm, HttpStatus.OK); + } + +// get by id + @GetMapping("/Sure_Connect/{id}") + public ResponseEntity getbyid(@PathVariable int id) { + Sure_Connect pm = sureService.getbyid(id); + + return new ResponseEntity<>(pm, HttpStatus.OK); + } + +// delete by id + @DeleteMapping("/Sure_Connect/{id}") + public ResponseEntity deleteOne(@PathVariable int id) { + + sureService.deletebyid(id); + return new ResponseEntity<>(HttpStatus.OK); + } + +// get by name + @GetMapping("/token/Sure_Connectbyname/{connection_name}") + public ResponseEntity getbyname(@PathVariable String connection_name) { + Sure_Connect pm = sureService.getbyname(connection_name); + + return new ResponseEntity<>(pm, HttpStatus.OK); + } + +} diff --git a/backend/src/main/java/com/realnet/SureConnect/Controller/Sure_Postman_Api.java b/backend/src/main/java/com/realnet/SureConnect/Controller/Sure_Postman_Api.java new file mode 100644 index 0000000..0bae004 --- /dev/null +++ b/backend/src/main/java/com/realnet/SureConnect/Controller/Sure_Postman_Api.java @@ -0,0 +1,140 @@ +package com.realnet.SureConnect.Controller; + +import java.util.ArrayList; +import java.util.List; + +import org.slf4j.Logger; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.client.RestTemplate; + +@RestController +@RequestMapping("/sure_connect/sure_postman") +public class Sure_Postman_Api { + + Logger log = org.slf4j.LoggerFactory.getLogger(Sure_Postman_Api.class); + + @PostMapping("/call_api") + public ResponseEntity calldifferentmethod(@RequestBody String json_body, + @RequestParam String api_url, + //@RequestParam String json_body, + @RequestParam String method, @RequestParam String token) { + + + log.info("executing no json_bodyeters"); + + if (method.equalsIgnoreCase("DELETE")) { + Object body = DELETE(api_url,token); + + return new ResponseEntity<>(body, HttpStatus.OK); + } else { + Object object = callmethod(api_url, json_body, method, token); + + System.out.println(object); + return new ResponseEntity<>(object, HttpStatus.OK); + + } + } + + // CALL METHOD + public Object callmethod(String urll, String json_body, String method, String token) { + + + + if (method.equalsIgnoreCase("GET")) { + ResponseEntity get = GET(urll,token); + Object body = get.getBody(); + System.out.println(body); + return get.getBody(); + } + + else if (method.equalsIgnoreCase("POST")) { + ResponseEntity post = POST(urll, json_body, token); + Object body = post.getBody(); + System.out.println(body); + + return post.getBody(); + + } else if (method.equalsIgnoreCase("PUT")) { + ResponseEntity put = PUT(urll, json_body, token); + Object body = put.getBody(); + System.out.println(body); + + return put.getBody(); + + } else { + return null; + } + + } + + private HttpHeaders getHeaders() { + HttpHeaders headers = new HttpHeaders(); + headers.set("Content-Type", MediaType.APPLICATION_JSON_VALUE); + headers.set("Accept", MediaType.APPLICATION_JSON_VALUE); + return headers; + } + + public ResponseEntity GET(String url,String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = url; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity( headers); +// ResponseEntity u = restTemplate.getForEntity(url, Object.class); + ResponseEntity u = restTemplate.exchange(resourceUrl, HttpMethod.GET, request, Object.class); + + return u; + + } + + public ResponseEntity POST(String jobinfo, Object user, String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = jobinfo; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity(user, headers); + ResponseEntity res = restTemplate.postForEntity(resourceUrl, request, Object.class); + + return res; + + } + + public ResponseEntity PUT(String jobinfo, Object user, String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = jobinfo; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity(user, headers); +// ResponseEntity res = restTemplate.put(resourceUrl, request, Object.class); + ResponseEntity res = restTemplate.exchange(resourceUrl, HttpMethod.PUT, request, Object.class); + + return res; + + } + + public Object DELETE(String url, String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = url; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity(headers); +// ResponseEntity u = restTemplate.getForEntity(url, Object.class); + ResponseEntity u = restTemplate.exchange(resourceUrl, HttpMethod.DELETE, request, Object.class); + return u; +// restTemplate.delete(url, Object.class); + } +} diff --git a/backend/src/main/java/com/realnet/SureConnect/Entities/Sure_Connect.java b/backend/src/main/java/com/realnet/SureConnect/Entities/Sure_Connect.java new file mode 100644 index 0000000..d973679 --- /dev/null +++ b/backend/src/main/java/com/realnet/SureConnect/Entities/Sure_Connect.java @@ -0,0 +1,30 @@ +package com.realnet.SureConnect.Entities; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.GenerationType; +import javax.persistence.Id; + +import lombok.Data; + +@Entity +@Data +public class Sure_Connect { + + @Id + @GeneratedValue(strategy =GenerationType.AUTO) + private int id; + + private String connection_name; + + @Column(length = 10000) + private String description; + + private String type; + private String access_token; + private int client_id; + private String username; + private String password; + +} diff --git a/backend/src/main/java/com/realnet/SureConnect/Repository/SureRepository.java b/backend/src/main/java/com/realnet/SureConnect/Repository/SureRepository.java new file mode 100644 index 0000000..59bfd7b --- /dev/null +++ b/backend/src/main/java/com/realnet/SureConnect/Repository/SureRepository.java @@ -0,0 +1,16 @@ +package com.realnet.SureConnect.Repository; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.stereotype.Repository; + +import com.realnet.SureConnect.Entities.Sure_Connect; + +@Repository +public interface SureRepository extends JpaRepository{ + + Sure_Connect findById(int id); + + @Query(value = "select * from sure_connect where connection_name=?1 ", nativeQuery = true) + Sure_Connect findByConnection_name(String connection_name); +} diff --git a/backend/src/main/java/com/realnet/SureConnect/Service/SureService.java b/backend/src/main/java/com/realnet/SureConnect/Service/SureService.java new file mode 100644 index 0000000..a786a35 --- /dev/null +++ b/backend/src/main/java/com/realnet/SureConnect/Service/SureService.java @@ -0,0 +1,61 @@ +package com.realnet.SureConnect.Service; + +import java.util.List; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import com.realnet.SureConnect.Entities.Sure_Connect; +import com.realnet.SureConnect.Repository.SureRepository; +import com.realnet.exceptions.ResourceNotFoundException; + +@Service +public class SureService { + + @Autowired + private SureRepository sureRepository; + + public Sure_Connect create(Sure_Connect sure_Connect) { + return sureRepository.save(sure_Connect); + } + + + public List getall() { + return (List) sureRepository.findAll(); + } + + + public Sure_Connect getbyid(int id) { + return sureRepository.findById(id); + } + + public Sure_Connect getbyname(String connection_name) { + return sureRepository.findByConnection_name(connection_name); + } + + + public Sure_Connect update(Sure_Connect sure, int id) { + Sure_Connect pm = sureRepository.findById(id); +// .orElseThrow(()->new ResourceNotFoundException("not found")); + + pm.setAccess_token(sure.getAccess_token()); + pm.setClient_id(sure.getClient_id()); + pm.setConnection_name(sure.getConnection_name()); + pm.setDescription(sure.getDescription()); + pm.setPassword(sure.getPassword()); + pm.setType(sure.getType()); + pm.setUsername(sure.getUsername()); + return sureRepository.save(pm); + } + + + public void deletebyid(int id) { + sureRepository.deleteById(id); + } + + + + + + +} diff --git a/backend/src/main/java/com/realnet/config/sqlite/SQLiteDialect.java b/backend/src/main/java/com/realnet/config/sqlite/SQLiteDialect.java new file mode 100644 index 0000000..e5e2df8 --- /dev/null +++ b/backend/src/main/java/com/realnet/config/sqlite/SQLiteDialect.java @@ -0,0 +1,35 @@ +//package com.realnet.config.sqlite; +// +//import java.sql.Types; +//import org.hibernate.dialect.Dialect; +//import org.hibernate.dialect.identity.IdentityColumnSupport; +// +//public class SQLiteDialect extends Dialect { +// +// public SQLiteDialect() { +// registerColumnType(Types.INTEGER, "integer"); +// registerColumnType(Types.VARCHAR, "text"); +// registerColumnType(Types.BLOB, "blob"); +// registerColumnType(Types.REAL, "real"); +// } +// +// @Override +// public IdentityColumnSupport getIdentityColumnSupport() { +// return new SQLiteIdentityColumnSupport(); +// } +// +// @Override +// public boolean hasAlterTable() { +// return false; +// } +// +// @Override +// public boolean dropConstraints() { +// return false; +// } +// @Override +// public boolean supportsUnionAll() { +// return true; +// } +// +//} diff --git a/backend/src/main/java/com/realnet/config/sqlite/SQLiteIdentityColumnSupport.java b/backend/src/main/java/com/realnet/config/sqlite/SQLiteIdentityColumnSupport.java new file mode 100644 index 0000000..0af923e --- /dev/null +++ b/backend/src/main/java/com/realnet/config/sqlite/SQLiteIdentityColumnSupport.java @@ -0,0 +1,22 @@ +//package com.realnet.config.sqlite; +// +//import org.hibernate.dialect.identity.IdentityColumnSupportImpl; +// +//public class SQLiteIdentityColumnSupport extends IdentityColumnSupportImpl { +// +// @Override +// public boolean supportsIdentityColumns() { +// return true; +// } +// +// @Override +// public String getIdentitySelectString(String table, String column, int type) { +// return "select last_insert_rowid()"; +// } +// +// @Override +// public String getIdentityColumnString(int type) { +// // SQLite mein sirf "integer" + auto increment hota hai +// return "integer"; +// } +//} \ No newline at end of file diff --git a/backend/src/main/java/com/realnet/config/sqlite/SQLiteUtil.java b/backend/src/main/java/com/realnet/config/sqlite/SQLiteUtil.java new file mode 100644 index 0000000..10b7ac2 --- /dev/null +++ b/backend/src/main/java/com/realnet/config/sqlite/SQLiteUtil.java @@ -0,0 +1,15 @@ +//package com.realnet.config.sqlite; +// +//import java.sql.Connection; +//import java.sql.DriverManager; +//import java.sql.SQLException; +// +//public class SQLiteUtil { +// +// private static final String DB_FILE = "realtest1.db"; // SQLite file +// +// public static Connection getConnection() throws SQLException { +// String url = "jdbc:sqlite:" + DB_FILE; +// return DriverManager.getConnection(url); +// } +//} diff --git a/backend/src/main/java/com/realnet/fnd/entity1/MenuDet.java b/backend/src/main/java/com/realnet/fnd/entity1/MenuDet.java index 35c26f7..3d8755a 100644 --- a/backend/src/main/java/com/realnet/fnd/entity1/MenuDet.java +++ b/backend/src/main/java/com/realnet/fnd/entity1/MenuDet.java @@ -1,28 +1,16 @@ package com.realnet.fnd.entity1; import java.util.ArrayList; -import java.util.Date; import java.util.List; import javax.persistence.Column; import javax.persistence.Entity; -import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.ManyToOne; import javax.persistence.Table; -import javax.persistence.Temporal; -import javax.persistence.TemporalType; import javax.persistence.Transient; -import org.springframework.data.annotation.CreatedDate; -import org.springframework.data.annotation.LastModifiedDate; - -import com.fasterxml.jackson.annotation.JsonFormat; -import com.fasterxml.jackson.annotation.JsonIgnore; - import lombok.AllArgsConstructor; import lombok.Getter; import lombok.NoArgsConstructor; diff --git a/backend/src/main/java/com/realnet/helper/CnsHelper.java b/backend/src/main/java/com/realnet/helper/CnsHelper.java new file mode 100644 index 0000000..54c2291 --- /dev/null +++ b/backend/src/main/java/com/realnet/helper/CnsHelper.java @@ -0,0 +1,222 @@ +package com.realnet.helper; + +import java.nio.charset.StandardCharsets; + +import org.apache.commons.codec.binary.Base64; +import org.slf4j.Logger; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; +import org.springframework.web.client.RestTemplate; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.realnet.utils.Port_Constant; + +public class CnsHelper { + + static Logger log = org.slf4j.LoggerFactory.getLogger(CnsHelper.class); + + // CONNECTOR CALL + public static String callconnector(String name) throws JsonProcessingException { + + String token = null; + ResponseEntity u = null; + RestTemplate restTemplate = new RestTemplate(); + String url = Port_Constant.BACKEND_PORTAL_DOMAIN + "/token/Sure_Connectbyname/" + name; + +// + try { + + u = restTemplate.getForEntity(url, Object.class); + + } catch (Exception e) { + + System.out.println(" token get error " + e); + + // TODO: handle exception + } + Object object = u.getBody(); + + if (object != null) { + + ObjectMapper mapper = new ObjectMapper(); + String str = mapper.writeValueAsString(object); + + JsonParser parser = new JsonParser(); + JsonElement element = parser.parse(str); + + JsonObject obj = element.getAsJsonObject(); + JsonElement tok = obj.get("access_token"); + System.out.println("token is == " + token); + token = tok.getAsString(); + } else { + System.out.println(" empty totek get ..."); + } + return token; + } + + public static ResponseEntity run(String urll, String param, String method, String token, String username, + String password) { + + log.info("executing no parameters"); + + if (method.equalsIgnoreCase("DELETE")) { + Object body = DELETE(urll); + + return new ResponseEntity<>(body, HttpStatus.OK); + } else { + Object object = callmethod(urll, param, method, token, username, password); + + System.out.println(object); + return new ResponseEntity<>(object, HttpStatus.OK); + + } + } + + public static boolean DELETE(String url) { + RestTemplate restTemplate = new RestTemplate(); + + restTemplate.delete(url, Object.class); + + return true; + + } + + // CALL METHOD + public static Object callmethod(String url, String param, String method, String token, String username, + String password) { + + if (method.equalsIgnoreCase("GET")) { + ResponseEntity get = GET(url); + Object body = get.getBody(); + System.out.println(body); + return get.getBody(); + } + + else if (method.equalsIgnoreCase("POST")) { + + ResponseEntity post; + if (username != null && password != null) { + post = POSTForBasicAuth(url, param, username, password); + + } else { + + post = POST(url, param, token); + } + Object body = post.getBody(); + System.out.println(body); + + return post.getBody(); + + } else if (method.equalsIgnoreCase("PUT")) { + ResponseEntity put = PUT(url, param, token); + Object body = put.getBody(); + System.out.println(body); + + return put.getBody(); + + } else { + return null; + } + + } + + public static ResponseEntity GET(String get) { + RestTemplate restTemplate = new RestTemplate(); + + ResponseEntity u = restTemplate.getForEntity(get, Object.class); + int statusCodeValue = u.getStatusCodeValue(); + System.out.println(statusCodeValue); + + return u; + + } + + public static ResponseEntity GET(String get, String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = get; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity(headers); + ResponseEntity u = restTemplate.exchange(resourceUrl, HttpMethod.GET, request, Object.class); + + int statusCodeValue = u.getStatusCodeValue(); + System.out.println(statusCodeValue); + + return u; + + } + + public static ResponseEntity POST(String jobinfo, Object user, String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = jobinfo; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity(user, headers); + ResponseEntity res = restTemplate.postForEntity(resourceUrl, request, Object.class); + + return res; + + } + + public static ResponseEntity POSTForBasicAuth(String jobinfo, Object user, String username, + String password) { + + System.out.println(" call basic auth.."); + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = jobinfo; + + String auth = username + ":" + password; + byte[] encodedAuth = Base64.encodeBase64(auth.getBytes(StandardCharsets.US_ASCII)); + String authHeader = "Basic " + new String(encodedAuth); + + HttpHeaders headers = getHeaders(); + + headers.set("Authorization", authHeader); + + HttpEntity request = new HttpEntity<>(user.toString(), headers); + ResponseEntity res = null; + try { + + res = restTemplate.postForEntity(resourceUrl, request, Object.class); + } catch (Exception e) { + + System.out.println(" call basic auth error " + e); + // TODO: handle exception + } + + return res; + + } + + public static ResponseEntity PUT(String jobinfo, Object user, String token) { + RestTemplate restTemplate = new RestTemplate(); + String resourceUrl = jobinfo; + String token1 = "Bearer " + token; + HttpHeaders headers = getHeaders(); + headers.set("Authorization", token1); + HttpEntity request = new HttpEntity(user, headers); +// ResponseEntity res = restTemplate.put(resourceUrl, request, Object.class); + ResponseEntity res = restTemplate.exchange(resourceUrl, HttpMethod.PUT, request, Object.class); + + return res; + + } + + private static HttpHeaders getHeaders() { + HttpHeaders headers = new HttpHeaders(); + headers.set("Content-Type", MediaType.APPLICATION_JSON_VALUE); + headers.set("Accept", MediaType.APPLICATION_JSON_VALUE); + return headers; + } + +} diff --git a/backend/src/main/java/com/realnet/session/controller/SessionController.java b/backend/src/main/java/com/realnet/session/controller/SessionController.java index b8e4340..61902c5 100644 --- a/backend/src/main/java/com/realnet/session/controller/SessionController.java +++ b/backend/src/main/java/com/realnet/session/controller/SessionController.java @@ -59,6 +59,7 @@ import com.realnet.users.entity.LoginUser; import com.realnet.users.entity.Role; import com.realnet.users.entity.Sys_Accounts; import com.realnet.users.entity1.AppUser; +import com.realnet.users.entity1.AppUserRole; import com.realnet.users.entity1.AppUserSessions; import com.realnet.users.entity1.Registration; import com.realnet.users.response.MessageResponse; @@ -156,11 +157,13 @@ public class SessionController { AppUser loggedInUser = userService.getLoggedInUser(); MDC.put("USER", loggedInUser.getUsername()); + AppUserRole usrGrp = loggedInUser.getUsrGrp(); + String groupName = usrGrp.getGroupName(); // System.out.println("/session logged in user -> " + loggedInUser); // List loggedInUserRoles = new ArrayList(); StringBuilder roleString = new StringBuilder(); - roleString.append(loggedInUser.getUsrGrp().getGroupName()); + roleString.append(groupName); // .forEach(role -> { //// loggedInUserRoles.add(role.getName()); // roleString.append(role.getName() + ", "); diff --git a/backend/src/main/java/com/realnet/users/controller1/AppUserController.java b/backend/src/main/java/com/realnet/users/controller1/AppUserController.java index 2ce80ef..9d245b0 100644 --- a/backend/src/main/java/com/realnet/users/controller1/AppUserController.java +++ b/backend/src/main/java/com/realnet/users/controller1/AppUserController.java @@ -104,6 +104,21 @@ public class AppUserController { return new ResponseEntity<>("User not found", HttpStatus.OK); } +// set iser active inactive + @GetMapping("/getOneAppUser/active/{id}") + public ResponseEntity getOneAppUser(@PathVariable("id") Long id, @RequestParam Boolean active) { + Optional a = appUserServiceImpl.getOneUser(id); + + if (a.get() != null) { + a.get().setActive(active); + + boolean insertOrSaveUser = appUserServiceImpl.insertOrSaveUser(a.get()); + + return new ResponseEntity<>(a.get(), HttpStatus.OK); + } + return new ResponseEntity<>("User not found", HttpStatus.OK); + } + @PostMapping("/addOneAppUser") public ResponseEntity addOneUser(@RequestBody Registration reg) { if (appUserRepository.findByEmail(reg.getEmail()) != null) { diff --git a/backend/src/main/java/com/realnet/users/controller1/SysAccountController.java b/backend/src/main/java/com/realnet/users/controller1/SysAccountController.java index f66106f..01fd520 100644 --- a/backend/src/main/java/com/realnet/users/controller1/SysAccountController.java +++ b/backend/src/main/java/com/realnet/users/controller1/SysAccountController.java @@ -5,7 +5,9 @@ import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.DeleteMapping; import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @@ -14,6 +16,7 @@ import com.realnet.session.entity.AboutWork; import com.realnet.users.entity.Sys_Accounts; import com.realnet.users.repository.AboutWorkRepo; import com.realnet.users.repository.SysAccountRepo; +import com.realnet.users.service1.SysAccountService; @RequestMapping("/token/users/sysaccount") @RestController @@ -25,9 +28,20 @@ public class SysAccountController { @Autowired private AboutWorkRepo aboutWorkRepo; + @Autowired + private SysAccountService accountService; + @PostMapping("/savesysaccount") public Sys_Accounts save(@RequestBody Sys_Accounts sys_Accounts) { - Sys_Accounts save = sysAccountRepo.save(sys_Accounts); + Sys_Accounts save = accountService.save(sys_Accounts); + + System.out.println("created account data is .." + save); + return save; + } + + @PutMapping("/savesysaccount/{accId}") + public Sys_Accounts updte(@PathVariable Long accId, @RequestBody Sys_Accounts sys_Accounts) { + Sys_Accounts save = accountService.update(accId, sys_Accounts); System.out.println("created account data is .." + save); return save; diff --git a/backend/src/main/java/com/realnet/users/entity1/AppUser.java b/backend/src/main/java/com/realnet/users/entity1/AppUser.java index 84577fb..10b316a 100644 --- a/backend/src/main/java/com/realnet/users/entity1/AppUser.java +++ b/backend/src/main/java/com/realnet/users/entity1/AppUser.java @@ -113,7 +113,7 @@ public class AppUser implements Serializable { private String password4; private Long pwdChangedCnt; private Date lastPwdChangedDate; - private Blob photo; +// private Blob photo; private String photoName; private String provider; @@ -157,7 +157,7 @@ public class AppUser implements Serializable { @Transient private StringBuilder totalLogInfo; - private String tshirtsize; +// private String tshirtsize; @Transient @JsonIgnore diff --git a/backend/src/main/java/com/realnet/users/service1/AppUserServiceImpl.java b/backend/src/main/java/com/realnet/users/service1/AppUserServiceImpl.java index 0a9978e..98482dc 100644 --- a/backend/src/main/java/com/realnet/users/service1/AppUserServiceImpl.java +++ b/backend/src/main/java/com/realnet/users/service1/AppUserServiceImpl.java @@ -392,9 +392,9 @@ public class AppUserServiceImpl implements UserDetailsService, AppUserService { a.setNotification( appUserDto.getNotification() != null ? appUserDto.getNotification() : a.getNotification()); - if (appUserDto.getTshirtsize() != null) { - a.setTshirtsize(appUserDto.getTshirtsize()); - } +// if (appUserDto.getTshirtsize() != null) { +// a.setTshirtsize(appUserDto.getTshirtsize()); +// } a.setMob_no(appUserDto.getMob_no()); a.setActive(appUserDto.isActive()); @@ -530,7 +530,7 @@ public class AppUserServiceImpl implements UserDetailsService, AppUserService { AppUser save = appUserRepository.save(a); System.out.println("Password changed Successfully.. "); - return new ResponseEntity<>(save, HttpStatus.ACCEPTED); + return new ResponseEntity<>("Password changed Successfully", HttpStatus.ACCEPTED); } diff --git a/backend/src/main/java/com/realnet/users/service1/SysAccountService.java b/backend/src/main/java/com/realnet/users/service1/SysAccountService.java index be4a2bb..289aac8 100644 --- a/backend/src/main/java/com/realnet/users/service1/SysAccountService.java +++ b/backend/src/main/java/com/realnet/users/service1/SysAccountService.java @@ -5,6 +5,7 @@ import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import com.itextpdf.text.pdf.PdfStructTreeController.returnType; import com.realnet.users.entity.Sys_Accounts; import com.realnet.users.repository.SysAccountRepo; @@ -15,12 +16,64 @@ public class SysAccountService { private SysAccountRepo sysAccountRepo; public Sys_Accounts save(Sys_Accounts sys) { + + Sys_Accounts account = findByEmail(sys.getEmail()); + if (account != null) { + + } + + sys.setActive(true); Sys_Accounts accounts = sysAccountRepo.save(sys); return accounts; } +// update sysaccount + + public Sys_Accounts update(Long accountId, Sys_Accounts request) { + + Sys_Accounts account = sysAccountRepo.findById(accountId).get(); + // account_id generally auto-generated hai, update me change nahi karenge + + if (request.getCompanyName() != null) { + account.setCompanyName(request.getCompanyName()); + } + + if (request.getWorkspace() != null) { + account.setWorkspace(request.getWorkspace()); + } + + if (request.getGstNumber() != null) { + account.setGstNumber(request.getGstNumber()); + } + + if (request.getMobile() != null) { + account.setMobile(request.getMobile()); + } + + if (request.getEmail() != null) { + account.setEmail(request.getEmail()); + } + + if (request.getPancard() != null) { + account.setPancard(request.getPancard()); + } + + if (request.getWorking() != null) { + account.setWorking(request.getWorking()); + } + + if (request.getActive() != null) { + account.setActive(request.getActive()); + } + + Sys_Accounts save = sysAccountRepo.save(account); + + return save; + + } + public List getall() { List getall = sysAccountRepo.findAll();