<settings>
    <proxies>
    <proxy>
    	<id>proxy-http</id>
    	<active>true</active>
    	<protocol>http</protocol>
    	<host>168.219.61.252</host> // 사업장 Proxy 정보
    	<port>8080</port> // 사업장 Proxy 정보
    	<nonProxyHosts>*.samsung.net|localhost|127.0.0.1</nonProxyHosts>
    </proxy>
    <proxy>
    	<id>proxy-https</id>
    	<active>true</active>
    	<protocol>https</protocol>
    	<host>168.219.61.252</host> // 사업장 Proxy 정보
    	<port>8080</port> // 사업장 Proxy 정보
    	<nonProxyHosts >*.samsung.net|localhost|127.0.0.1</nonProxyHosts>
    </proxy>
    </proxies>
</settings>

# Datasource(Postgresql)
datasource.driver=ENC(zg2s0lzTKz1OADpB2LmIk7pcJNLonCsW4WerSDJ9WTfmimam1Zi0Z8mH16+mWY+y)
datasource.url=ENC(QaTWEyV020nKVDYneWGs8WNrezY8FGOKyleE2pkxlSs8m8nXE2/mqYMSaqAwUJghMJnLp20twDvdHh4csOKDzw==)
datasource.username=ENC(Vz2UR99au+VBAaVJBDSdLw==)
datasource.password=ENC(Wrer0/kHw+6UyGhtBT+bdSZNo83x+HNB)

@Bean
public SqlSessionFactoryBean defaultSqlSessionFactory(DataSource dataSource,
                                                      ApplicationContext applicationContext) throws IOException {
    SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
    factoryBean.setDataSource(dataSource);
    factoryBean.setConfigLocation(applicationContext.getResource("classpath:sql/mybatis/postgresql/mybatis-config.xml"));
    factoryBean.setMapperLocations(applicationContext.getResources("classpath*:sql/mybatis/postgresql/**/mapper-mybatis-*.xml"));
    return factoryBean;
}

    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.3</version>
        <exclusions>
            <exclusion>
                <groupId>org.checkerframework</groupId>
                <artifactId>checker-qual</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

C:\~YOUR~PROJECT~PATH~\sdl-base\frontend>npm install

server: {
  // host: 'localhost' // default
  port: '8081',
}

VITE_NODE_ENV=local
VITE_API_URL=http://localhost:8080
VITE_DIST_PATH=../src/main/resources/public
VITE_WEB_CONTEXT_PATH=/

C:\~YOUR~PROJECT~PATH~\sdl-base\frontend>npm run local

# default env
VITE_NODE_ENV=production
VITE_API_URL=http://sdl.sec.samsung.net/administrator
VITE_DIST_PATH=../src/main/webapp/pp
# CONTEXT_PATH value must be end with '/'
VITE_WEB_CONTEXT_PATH=/

  "scripts": {
    "local": "vite --mode test",
    "dev": "vite --mode development",
    "prod": "vite --mode production",
    "build": "vite build --mode production",
    "build-test": "vite build --mode test",
    "build-dev": "vite build --mode development",
    "build-prod": "vite build --mode production",
    "preview": "vite preview --mode production",
    "preview-test": "vite preview --mode test",
    "preview-dev": "vite preview --mode development",
    "preview-prod": "vite preview --mode production",
    "lint": "eslint src/**/*.{vue,js}"
  },

npm install sonar-scanner -g

cd sdl-base (1)

sonar-scanner -Dsonar.host.url=SonarQube서버URL -Dsonar.projectKey=프로젝트Key -Dsonar.projectName=프로젝트명 -Dsonar.projectVersion=프로젝트버전 -Dsonar.login=아이디 -Dsonar.password=패스워드 -Dsonar.sources=frontend/src (2)

mvn clean package -Pprod

sdl-base
 |- doc (1)
 |- frontend (2)
 |- src/main/java (3)
 |- src/main/resource (4)
 |- source (6)
 |- pom.xml

com
|- onelogin.saml2 (1)
|- samsung
    |- aspect (2)
    |- batch (3)
    |- common (4)
    |- config (5)
    |- filter (6)
    |- interceptor (7)
    |- sample (8)
    |- user.controller (9)

resources
    |- excel :  excel up/download mapping xml 파일
    |- message : spring message properties 파일
    |- sql.mybatis : mybatis query mapper xml  파일
    |- templates : 결재/메일 vm 파일

resources-local
    |- application.properties : spring boot 설정 파일
    |- config.properties : sdl의 설정 파일
    |- knox.properties : knox 설정
    |- log4j2.xml : log4j2 설정
    |- onelogin.saml.properties : AD 통합 인증 설정 파일

frontend
 |- public (1)
 |- src (2)
 |- static (3)
 |- .env (4)
 |- index.html (5)
 |- package.json (6)
 |- .prettierrc.json (7)
 |- eslint.config.js (8)
 |- vite.config.js (9)

src
 |- components (1)
 |- constants (2)
 |- directives (3)
 |- event (4)
 |- filters (5)
 |- i18n (6)
 |- mixin (7)
 |- router (8)
 |- service (9)
 |- utils (10)
 |- vuex (11)

components
 |- common
    |- control (1)
    |- popup (2)
 |- view
    |- admin
        |- approval (3)
        |- approvalTemplate (4)
        |- batch (5)
        |- board (6)
        |- dept (7)
        |- etc (8)
        |- htmlTemplate (9)
        |- log (10)
        |- main (11)
        |- menu (12)
        |- role (13)
        |- sample (14)
        |- user (15)
        |- workgroup (16)
    |- sample (17)

// v-directive 의 기본 구조
export default {
  beforeMount(el, binding, vnode) {
    // console.log('bind');
  },
  mounted(el, binding, vndoe) {
    // console.log('inserted');
  },
  updated(el, binding, vnode, oldVnode) {
    // console.log('componentUpdated');
  },
};

// directive install 정의
import custom from './custom';
import clickOutSide from './clickOutside';
import regex from './regex';
import authorization from './authorization';
import validation from './validation';

export default {
  install(Vue) {
    Vue.directive('custom', custom);
    Vue.directive('click-outside', clickOutSide);
    Vue.directive('regex', regex);
    Vue.directive('authorization', authorization);
    Vue.directive('validation', validation);
  },
};

// directive 사용
// ... 생략 ...
import SdlDirectives from './directives';

app.use(SdlDirectives);
// ... 생략 ...
};

// filter install 정의
import dateFormat from './dateFormat';
import numberFormat from './numberFormat';
import reverse from './reverse';
import nl2br from './nl2br';
import cutString from './cutString';

export default {
  install(Vue) {
    Vue.config.globalProperties.$filters = {
      reverse: reverse,
      dateFormat: dateFormat,
      numberFormat: numberFormat,
      nl2br: nl2br,
      cutString: cutString,
    };
  },
};

<span class="ui--text-total">
    <strong>Total</strong> {{ $filters.numberFormat(total) }}
</span>

{
    searchColumn : '검색할 컬럼'(name : '이름', knoxId :'knoxId 아이디')
    searchTxt : '검색할 text'('like로 검색됨')
    rtnFunc : '검색한 내용을 return받을 function'
 }

@Cacheable(value = "message-all")
public Map<String, Map<String, String>> getMessage() {
    Map<String, Map<String, String>> message = new HashMap<>();
    for (String locale : languageSet) {
        message.put(locale, getMessageByLang(new Locale(locale.split("_")[0], locale.split("_")[1])));
    }
    return message;
}

@Cacheable(value = "message", key = "#locale")
public Map<String, String> getMessageByLang(Locale locale) {
    Set<String> beanNames = messageSource.getBasenameSet();
    Map<String, String> message = new HashMap<>();
    for (String beanName : beanNames) {
        ResourceBundle resourceBundle = ResourceBundle.getBundle(StringUtils.remove(beanName, "classpath:/"), locale);
        Enumeration<String> keys = resourceBundle.getKeys();
        while (keys.hasMoreElements()) {
            String key = keys.nextElement();
            String javaVersion = StringUtils.substringBeforeLast(System.getProperty("java.version"), ".");
            if (Float.parseFloat(javaVersion) < 1.9) {
                message.put(key, new String(resourceBundle.getString(key).getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8));
            } else {
                message.put(key, resourceBundle.getString(key));
            }
        }
    }
    return message;
}

@Cacheable(value = "menu-all")
@Override
public List<Map<String, String>> getAllMenuPagePaths() {
    return menuDao.getAllMenuPagePaths();
}

@Override
@Cacheable(value = "api-user", key = "#userId")
public List<Api> getUserAuthApiListByUserId(String userId) {
    return apiDao.getUserAuthApiListByUserId(userId);
}

@Override
@Cacheable(value = "api-user-menu", key = "#userId.concat(':').concat(#menuId)")
public List<Api> getUserAuthApiListByUserIdAndMenuId(String userId, String menuId) {
    return apiDao.getApiListByUserIdAndMenuId(userId, menuId);
}

@Cacheable(value = "page-all-by-menu-auth")
public Map<String, Map<String, List<Page>>> getAllPageListByAuth() {
    log.debug("PageService Start.");
    Map<String, Map<String, List<Page>>> menuAuthMap = new HashMap<>();

    Map<String, List<Page>> menuMap = getAllPageListByMenu();
    for (Map.Entry<String, List<Page>> entry : menuMap.entrySet()) {

        List<Page> authPageList = entry.getValue();
        Map<String, List<Page>> authMap = new HashMap<>();

        authMap.put("READ", authPageList.stream().filter(page -> "READ".equals(page.getAuthorizationType())).collect(Collectors.toList()));
        authMap.put("UPDATE", authPageList.stream().filter(page -> "UPDATE".equals(page.getAuthorizationType())).collect(Collectors.toList()));
        authMap.put("DOWNLOAD", authPageList.stream().filter(page -> "DOWNLOAD".equals(page.getAuthorizationType())).collect(Collectors.toList()));
        authMap.put("EXECUTE", authPageList.stream().filter(page -> "EXECUTE".equals(page.getAuthorizationType())).collect(Collectors.toList()));
        menuAuthMap.put(entry.getKey(), authMap);
    }
    log.debug("menuAuthMap : {}", menuAuthMap);
    return menuAuthMap;
}

@Cacheable(value="page-full-path-all")
@Override
public Map<String, String> getPageFullPathList() {

    List<Map<String, String>> pageFullPathList = menuDao.getPageFullPathList();

    Map<String, String> pageFullPathMap = new HashMap<>();

    for(Map<String, String> pageFullPath : pageFullPathList) {
        pageFullPathMap.put(pageFullPath.get("pageId"), pageFullPath.get("fullPath"));
    }

    return pageFullPathMap;
}

@SpringBootApplication
public class SdlBaseBootApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SdlBaseBootApplication.class);
    }

    public static void main(String[] args) {
        SpringApplication.run(SdlBaseBootApplication.class, args);
    }

}

@Configuration
@Profile({"local"})
public class DbcpDataSourceConfig {

<tx:annotation-driven transaction-manager="txManager" />

@Value("${security.access.limit.timeout:30}")
private int limitTimeout;

@Value("${security.check.access.timeout:false}")
private boolean checkTimeout;

String functionUrl = environment.getProperty(KNOX_EMP_SERVICE) + "/employees";

@ComponentScan(basePackages = "com.samsung", useDefaultFilters = false, includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Service.class), @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Repository.class), @ComponentScan.Filter(type = FilterType.ANNOTATION, value = Component.class)})

<mvc:annotation-driven/>

@Configuration
@EnableWebMvc
public class SpringWebConfig implements WebMvcConfigurer {
}

@ComponentScan(basePackages = "com.samsung", useDefaultFilters = false, includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION, value = Controller.class), @ComponentScan.Filter(type = FilterType.ANNOTATION, value = EnableSwagger2.class)})

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    registry.addResourceHandler("index.html").
            addResourceLocations(webResourceRoot);
    registry.addResourceHandler("favicon.ico").
            addResourceLocations(webResourceRoot + "static/");
    registry.addResourceHandler("static/**")
            .addResourceLocations(webResourceRoot + "static/");
    registry.addResourceHandler("swagger-ui.html")
            .addResourceLocations("classpath:/META-INF/resources/");
    registry.addResourceHandler("/webjars/**")
            .addResourceLocations("classpath:/META-INF/resources/webjars/");
}

    @Value("${common.upload.max-request-size:-1}")
    private long maxRequestSize;
    @Value("${common.upload.max-file-size:-1}")
    private long maxFileSize;


    @Bean
    public MultipartResolver multipartResolver() {
        return new StandardServletMultipartResolver();
    }

    @Bean
    public MultipartConfigElement multipartConfigElement() {
        MultipartConfigFactory factory = new MultipartConfigFactory();
        factory.setMaxRequestSize(DataSize.ofBytes(maxRequestSize));
        factory.setMaxFileSize(DataSize.ofBytes(maxFileSize));

        return factory.createMultipartConfig();
    }

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) {
	String requestMethod = request.getMethod();
    if(HttpMethod.OPTIONS.name().equals(requestMethod)) {
    	return;
    }
    String requestURI = request.getRequestURI().substring(request.getContextPath().length());


    SimpleDateFormat formatter = new SimpleDateFormat("yyyyMMdd HHmmssSSS", Locale.getDefault());
    String sTime = formatter.format(new Date());

    long start = (long) request.getAttribute("start");
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);

    String userId = "anonymous";
    if (ObjectUtils.isNotEmpty(Account.currentUser())) {
        userId = Account.currentUser().getUserId();
    }

    String getDecodedRequestURI = WebUtil.getDecodedRequestUrl(request, requestURI);
    SysUseLog sysUseLog = new SysUseLog();
    sysUseLog.setLogOccurId(idGenService.getNextStringId());

    String menuId = request.getHeader("menu-Id");
    String pageId = request.getHeader("page-id");
    if(pageId != null) sysUseLog.setDescription(menuService.getPageFullPath(pageId));

    sysUseLog.setNodeId(node);
    sysUseLog.setUserId(userId);
    sysUseLog.setUseFromDate(sTime.substring(0, 8));
    sysUseLog.setUseFromHhmmss(sTime.substring(9, 15));
    sysUseLog.setUseThruDatetime(new Date());
    sysUseLog.setResponseTime(elapsedTime);
    sysUseLog.setPath(getDecodedRequestURI);

    String query = request.getQueryString();
    if (query != null) {
        try {
            query = URLDecoder.decode(query, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            log.error(e.getMessage(), e);
        }
        String queryStr = StringUtils.replace(query, "'", "\\'");
        sysUseLog.setParameter(queryStr);
        sysUseLog.setUrl(requestURI + "?" + queryStr);
    }
    sysUseLog.setUseIp(WebUtil.getClientIp(request));
    sysUseLog.setBrowserTypeName(request.getHeader("User-Agent"));
    sysUseLog.setLogFlag(LogFlag.ACCESSLOG.getValue());
    sysUseLog.setReqType(ReqType.WEB);
    sysUseLog.setFirstRegDatetime(new Date());

    sysUseLog.setMenuId(menuId);
    sysUseLog.setPageId(pageId);
    sysUseLog.setMethod(requestMethod);

    // 대리 로그인 시 별도 이력 남김
    String originalUserId = request.getHeader("original-user-id");
    if(StringUtils.isNotEmpty(originalUserId)){
        sysUseLog.setLogFlag(LogFlag.IMPERSONATION_ACCESS.getValue());
        sysUseLog.setDescription("Original User Id : " + originalUserId);
    }

    try {
        if ("db".equalsIgnoreCase(storeType)) {
            accessLogService.insertAccessLog(sysUseLog);
        } else {
            accessLogService.logAccess(sysUseLog);
        }
    } catch (Exception e) {
        log.error(e.getMessage());
    }
}

String token = request.getHeader("x-auth-token"); (1)
// Token 값 유무
if (StringUtils.isEmpty(token)) {
    throw new NotFoundTokenException("Not Found Token");
}

axios.defaults.headers.common['x-auth-token'] = localStorage.getItem('userToken');

String originalUserId = request.getHeader("original-user-id"); (1)

Boolean jwtValid = jwtUtil.validateToken(token, user); (1)
if (Boolean.TRUE.equals(jwtValid)) {
    if (user.isActiveFlag()) {
        user.setSystemAdminUser(roleService.isSystemAdmin(userId));
        Account.updateCurrentAccount(user);
        return true;
    } else {
        // 시스템 승인 대기중
        throw new WaitingUserException("Waiting User"); (2)
    }
} else {
    throw new InvalidTokenException("Token Expired");
}

if (user == null) throw new NoSearchUserException("No Search User"); (1)
if (roleService.isSystemAdmin(user.getUserId())) { (2)
	if(adminAddressCheck) {
		List<String> adminAddresses = adminAddressService.getAdminAddresses(null); (3)
		String remoteAddr = WebUtil.getClientIp(request);
		if(ObjectUtils.isNotEmpty(adminAddresses) && !adminAddresses.contains(remoteAddr)) {
			throw new AuthorizationException("Remote address is not admin ip address.");
		}
	}
	return true;
}

for (Api api : authMenuList) {
    if (api.getHttpMethod().equals(httpMethod) && checkUriMatch(api.getApiPath(), api.getApiParameters(), decodedUrl, queryString)) {
        return true;
    }
}
throw new AuthorizationException("API 권한 없음");

/**
 * 약관동의 사용 여부
 */
@Value("${privacy-policy.check.enabled:true}")
private boolean privacyPolicyCheck;

/**
 * 약관동의 인터셉터 체크 제외 URI
 */
@Value("${privacy-policy.check.exclude-path}")
private String privacyPolicyCheckExcludePath;

if (user != null && !user.isPrivacyPolicy()) {
    throw new PrivacyPolicyException("Privacy policy agreement required.");
} else {
    return true;
}

@Value("${security.access.limit.timeout:30}")
private int limitTimeout;

static final long MILLISECONDS_PER_MINUTE = 60L*1000L;

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler){
    String lastAccessTimeHeader = request.getHeader("last-access-time");
    String impersonate = request.getHeader("original-user-id");
    if(StringUtils.isNotEmpty(lastAccessTimeHeader) && !StringUtils.equals("undefined", lastAccessTimeHeader) && !StringUtils.equals("NaN", lastAccessTimeHeader) && StringUtils.isEmpty(impersonate)){
        long lastActivityTime = Long.parseLong(lastAccessTimeHeader);
        long currentTime = System.currentTimeMillis();
        long jwtRetentionTime = currentTime - lastActivityTime;
        if (jwtRetentionTime > (limitTimeout * MILLISECONDS_PER_MINUTE)) {
            //limitTimeout 동안 사용하지 않으면 자동 로그아웃
            throw new TokenRetentionTimeoutException("Token Retention Timeout");
        }
    }
    return true;
}

<div class="mb-2" style="position:relative;">
<label for="title">{{ $t('sdl.approval.label.title') }} <span class="text-required">&#42;</span></label>
<input
  id="title"
  type="text"
  class="form-control"
  v-model="apprDoc.title"
  :readonly="apprDoc.docStatus !== ''"
  v-validation=""
  :errorMessage="$t('sdl.department.message.requiredValue')"
/>
</div>

<tr>
    <th class="text-nowrap" scope="row">
        {{ $t('sdl.commonCode.label.order') }}
        <span class="text-required">*</span>
    </th>
    <td>
        <input type="number" min="0" max="99999" class="form-control" v-model.number="code.ord" v-validation="{ groupId: 'popup' }" />
    </td>
</tr>

<tr>
<th class="text-nowrap" scope="row">URL<span class="text-required">*</span></th>
<td>
<input
    id="linkSiteUrl"
    type="text"
    class="form-control"
    placeholder=""
    v-model.trim="linkInfo.url"
    v-validation="{
        groupId: '',
        valids: [
            {
                validFuncs: () => {
                    return linkInfo.url.length <= 250;
                },
                errorMessage: 'test err',
            },
            {
                validFuncs: () => {
                    return !checkPatternUrl(linkInfo.url);
                },
                errorMessage: 'sdl.samsung.validate.url',
            },
        ],
    }"
    :errorMessage="'sdl.department.message.requiredValue'"
/>
</td>
</tr>

if (SDLUtil.onSubmitValidation('popup')) return;

 {
  "ko_KR":{
    "data-format.time.hm":"HH:mm",
    "data-format.datetime.ymdhms":"YYYY-MM-DD HH:mm:ss",
    "data-format.time.hms":"HH:mm:ss",
    "data-format.date.ym":"YYYY-MM",
    "data-format.date.yw":"YYYY-W",
    "data-format.date.ymw":"YYYY-MM(W)",
    "data-format.date.ymd":"YYYY-MM-DD"
  },
  "en_US":{
    "data-format.time.hm":"HH:mm",
    "data-format.datetime.ymdhms":"YYYY-MM-DD HH:mm:ss",
    "data-format.time.hms":"HH:mm:ss",
    "data-format.date.ym":"YYYY-MM",
    "data-format.date.yw":"YYYY-W",
    "data-format.date.ymw":"YYYY-MM(W)",
    "data-format.date.ymd":"MM/DD/YYYY"
  }
}

firstRegDatetime: moment().format(SDLUtil.getMsgProp('data-format.date.ymd')),

<!-- Vue2 -->
<!-- default 'YYYY-MM-DD' -->
<small class="float-right">{{ row.regDate || dateFormat }}</small>
<!-- Vue3 -->
<small class="float-right">{{ $filters.dateFormat(row.regDate) }}</small>

<!-- Vue2 -->
<!-- 포맷을 임의로 지정 -->
<td class="text-center">{{ mail.sendDateTime || dateFormat($t('data-format.date.ymd')) }}</td>
<!-- Vue3 -->
<td class="text-center">{{ $filters.dateFormat(mail.sendDateTime, $t('data-format.date.ymd')) }}</td>