code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
@import "./assets/Inter/inter.css";
@import "frappe-ui/src/style.css";
ion-modal {
--height: auto;
}
input:disabled {
--webkit-text-fill-color: var(--tw-text-color);
opacity: 0.9; /* required on iOS */
color: var(--tw-text-color);
}
/* For Webkit-based browsers (Chrome, Safari and Opera) */
input::-webkit-date-and-time-value {
text-align: left;
}
body {
-webkit-tap-highlight-color: transparent;
}
.hide-scrollbar::-webkit-scrollbar {
display: none;
}
/* For IE, Edge and Firefox */
.hide-scrollbar {
-ms-overflow-style: none; /* IE and Edge */
scrollbar-width: none; /* Firefox */
}
|
2302_79757062/hrms
|
frontend/src/main.css
|
CSS
|
agpl-3.0
| 601
|
import { createApp } from "vue"
import App from "./App.vue"
import router from "./router"
import { initSocket } from "./socket"
import {
Button,
Input,
setConfig,
frappeRequest,
resourcesPlugin,
FormControl,
} from "frappe-ui"
import EmptyState from "@/components/EmptyState.vue"
import { IonicVue } from "@ionic/vue"
import { session } from "@/data/session"
import { userResource } from "@/data/user"
import { employeeResource } from "@/data/employee"
import dayjs from "@/utils/dayjs"
import getIonicConfig from "@/utils/ionicConfig"
import FrappePushNotification from "../public/frappe-push-notification"
/* Core CSS required for Ionic components to work properly */
import "@ionic/vue/css/core.css"
/* Theme variables */
import "./theme/variables.css"
import "./main.css"
const app = createApp(App)
const socket = initSocket()
setConfig("resourceFetcher", frappeRequest)
app.use(resourcesPlugin)
app.component("Button", Button)
app.component("Input", Input)
app.component("FormControl", FormControl)
app.component("EmptyState", EmptyState)
app.use(router)
app.use(IonicVue, getIonicConfig())
if (session?.isLoggedIn && !employeeResource?.data) {
employeeResource.reload()
}
app.provide("$session", session)
app.provide("$user", userResource)
app.provide("$employee", employeeResource)
app.provide("$socket", socket)
app.provide("$dayjs", dayjs)
const registerServiceWorker = async () => {
window.frappePushNotification = new FrappePushNotification("hrms")
if ("serviceWorker" in navigator) {
let serviceWorkerURL = "/assets/hrms/frontend/sw.js"
let config = ""
try {
config = await window.frappePushNotification.fetchWebConfig()
serviceWorkerURL = `${serviceWorkerURL}?config=${encodeURIComponent(
JSON.stringify(config)
)}`
} catch (err) {
console.error("Failed to fetch FCM config", err)
}
navigator.serviceWorker
.register(serviceWorkerURL, {
type: "classic",
})
.then((registration) => {
if (config) {
window.frappePushNotification.initialize(registration).then(() => {
console.log("Frappe Push Notification initialized")
})
}
})
.catch((err) => {
console.error("Failed to register service worker", err)
})
} else {
console.error("Service worker not enabled/supported by the browser")
}
}
router.isReady().then(() => {
if (import.meta.env.DEV) {
frappeRequest({
url: "/api/method/hrms.www.hrms.get_context_for_dev",
}).then((values) => {
if (!window.frappe) window.frappe = {}
window.frappe.boot = values
registerServiceWorker()
app.mount("#app")
})
} else {
registerServiceWorker()
app.mount("#app")
}
})
router.beforeEach(async (to, _, next) => {
let isLoggedIn = session.isLoggedIn
try {
if (isLoggedIn) await userResource.reload()
} catch (error) {
isLoggedIn = false
}
if (!isLoggedIn) {
// password reset page is outside the PWA scope
if (to.path === "/update-password") {
return next(false)
} else if (to.name !== "Login") {
next({ name: "Login" })
}
}
if (isLoggedIn && to.name !== "InvalidEmployee") {
await employeeResource.promise
// user should be an employee to access the app
// since all views are employee specific
if (
!employeeResource?.data ||
employeeResource?.data?.user_id !== userResource.data.name
) {
next({ name: "InvalidEmployee" })
} else if (to.name === "Login") {
next({ name: "Home" })
} else {
next()
}
} else {
next()
}
})
|
2302_79757062/hrms
|
frontend/src/main.js
|
JavaScript
|
agpl-3.0
| 3,466
|
const routes = [
{
name: "EmployeeAdvanceListView",
path: "/employee-advances",
component: () => import("@/views/employee_advance/List.vue"),
},
{
name: "EmployeeAdvanceFormView",
path: "/employee-advances/new",
component: () => import("@/views/employee_advance/Form.vue"),
},
{
name: "EmployeeAdvanceDetailView",
path: "/employee-advances/:id",
props: true,
component: () => import("@/views/employee_advance/Form.vue"),
},
]
export default routes
|
2302_79757062/hrms
|
frontend/src/router/advances.js
|
JavaScript
|
agpl-3.0
| 475
|
const routes = [
{
name: "ExpenseClaimListView",
path: "/expense-claims",
component: () => import("@/views/expense_claim/List.vue"),
},
{
name: "ExpenseClaimFormView",
path: "/expense-claims/new",
component: () => import("@/views/expense_claim/Form.vue"),
},
{
name: "ExpenseClaimDetailView",
path: "/expense-claims/:id",
props: true,
component: () => import("@/views/expense_claim/Form.vue"),
},
]
export default routes
|
2302_79757062/hrms
|
frontend/src/router/claims.js
|
JavaScript
|
agpl-3.0
| 448
|
import { createRouter, createWebHistory } from "@ionic/vue-router"
import TabbedView from "@/views/TabbedView.vue"
import leaveRoutes from "./leaves"
import claimRoutes from "./claims"
import employeeAdvanceRoutes from "./advances"
import salarySlipRoutes from "./salary_slips"
const routes = [
{
path: "/",
redirect: "/home",
},
{
path: "/",
component: TabbedView,
children: [
{
path: "",
redirect: "/home",
},
{
path: "/home",
name: "Home",
component: () => import("@/views/Home.vue"),
},
{
path: "/dashboard/leaves",
name: "LeavesDashboard",
component: () => import("@/views/leave/Dashboard.vue"),
},
{
path: "/dashboard/expense-claims",
name: "ExpenseClaimsDashboard",
component: () => import("@/views/expense_claim/Dashboard.vue"),
},
{
path: "/dashboard/salary-slips",
name: "SalarySlipsDashboard",
component: () => import("@/views/salary_slip/Dashboard.vue"),
},
],
},
{
path: "/login",
name: "Login",
component: () => import("@/views/Login.vue"),
},
{
path: "/profile",
name: "Profile",
component: () => import("@/views/Profile.vue"),
},
{
path: "/notifications",
name: "Notifications",
component: () => import("@/views/Notifications.vue"),
},
{
path: "/settings",
name: "Settings",
component: () => import("@/views/AppSettings.vue"),
},
{
path: "/invalid-employee",
name: "InvalidEmployee",
component: () => import("@/views/InvalidEmployee.vue"),
},
...leaveRoutes,
...claimRoutes,
...employeeAdvanceRoutes,
...salarySlipRoutes,
]
const router = createRouter({
history: createWebHistory("/hrms"),
routes,
})
export default router
|
2302_79757062/hrms
|
frontend/src/router/index.js
|
JavaScript
|
agpl-3.0
| 1,691
|
const routes = [
{
name: "LeaveApplicationListView",
path: "/leave-applications",
component: () => import("@/views/leave/List.vue"),
},
{
name: "LeaveApplicationFormView",
path: "/leave-applications/new",
component: () => import("@/views/leave/Form.vue"),
},
{
name: "LeaveApplicationDetailView",
path: "/leave-applications/:id",
props: true,
component: () => import("@/views/leave/Form.vue"),
},
]
export default routes
|
2302_79757062/hrms
|
frontend/src/router/leaves.js
|
JavaScript
|
agpl-3.0
| 448
|
const routes = [
{
path: "/salary-slips/:id",
name: "SalarySlipDetailView",
props: true,
component: () => import("@/views/salary_slip/Detail.vue"),
},
]
export default routes
|
2302_79757062/hrms
|
frontend/src/router/salary_slips.js
|
JavaScript
|
agpl-3.0
| 186
|
import { io } from "socket.io-client"
import { socketio_port } from "../../../../sites/common_site_config.json"
import { getCachedListResource } from "frappe-ui/src/resources/listResource"
import { getCachedResource } from "frappe-ui/src/resources/resources"
export function initSocket() {
let host = window.location.hostname
let siteName = window.site_name
let port = window.location.port ? `:${socketio_port}` : ""
let protocol = port ? "http" : "https"
let url = `${protocol}://${host}${port}/${siteName}`
let socket = io(url, {
withCredentials: true,
reconnectionAttempts: 5,
})
socket.on("hrms:refetch_resource", (data) => {
if (data.cache_key) {
let resource =
getCachedResource(data.cache_key) ||
getCachedListResource(data.cache_key)
if (resource) {
resource.reload()
}
}
})
return socket
}
|
2302_79757062/hrms
|
frontend/src/socket.js
|
JavaScript
|
agpl-3.0
| 843
|
/* Ionic Variables and Theming. For more info, please see:
http://ionicframework.com/docs/theming/ */
/** Ionic CSS Variables **/
:root {
--ion-background-color: #f4f5f6;
--ion-font-family: "InterVar", sans-serif;
--ion-tab-bar-color-selected: #525252;
--ion-tab-bar-background-focused: #e2e2e2;
/** primary **/
--ion-color-primary: #3880ff;
--ion-color-primary-rgb: 56, 128, 255;
--ion-color-primary-contrast: #ffffff;
--ion-color-primary-contrast-rgb: 255, 255, 255;
--ion-color-primary-shade: #3171e0;
--ion-color-primary-tint: #4c8dff;
/** secondary **/
--ion-color-secondary: #3dc2ff;
--ion-color-secondary-rgb: 61, 194, 255;
--ion-color-secondary-contrast: #ffffff;
--ion-color-secondary-contrast-rgb: 255, 255, 255;
--ion-color-secondary-shade: #36abe0;
--ion-color-secondary-tint: #50c8ff;
/** tertiary **/
--ion-color-tertiary: #5260ff;
--ion-color-tertiary-rgb: 82, 96, 255;
--ion-color-tertiary-contrast: #ffffff;
--ion-color-tertiary-contrast-rgb: 255, 255, 255;
--ion-color-tertiary-shade: #4854e0;
--ion-color-tertiary-tint: #6370ff;
/** success **/
--ion-color-success: #2dd36f;
--ion-color-success-rgb: 45, 211, 111;
--ion-color-success-contrast: #ffffff;
--ion-color-success-contrast-rgb: 255, 255, 255;
--ion-color-success-shade: #28ba62;
--ion-color-success-tint: #42d77d;
/** warning **/
--ion-color-warning: #ffc409;
--ion-color-warning-rgb: 255, 196, 9;
--ion-color-warning-contrast: #000000;
--ion-color-warning-contrast-rgb: 0, 0, 0;
--ion-color-warning-shade: #e0ac08;
--ion-color-warning-tint: #ffca22;
/** danger **/
--ion-color-danger: #eb445a;
--ion-color-danger-rgb: 235, 68, 90;
--ion-color-danger-contrast: #ffffff;
--ion-color-danger-contrast-rgb: 255, 255, 255;
--ion-color-danger-shade: #cf3c4f;
--ion-color-danger-tint: #ed576b;
/** dark **/
--ion-color-dark: #222428;
--ion-color-dark-rgb: 34, 36, 40;
--ion-color-dark-contrast: #ffffff;
--ion-color-dark-contrast-rgb: 255, 255, 255;
--ion-color-dark-shade: #1e2023;
--ion-color-dark-tint: #383a3e;
/** medium **/
--ion-color-medium: #92949c;
--ion-color-medium-rgb: 146, 148, 156;
--ion-color-medium-contrast: #ffffff;
--ion-color-medium-contrast-rgb: 255, 255, 255;
--ion-color-medium-shade: #808289;
--ion-color-medium-tint: #9d9fa6;
/** light **/
--ion-color-light: #f4f5f8;
--ion-color-light-rgb: 244, 245, 248;
--ion-color-light-contrast: #000000;
--ion-color-light-contrast-rgb: 0, 0, 0;
--ion-color-light-shade: #d7d8da;
--ion-color-light-tint: #f5f6f9;
}
|
2302_79757062/hrms
|
frontend/src/theme/variables.css
|
CSS
|
agpl-3.0
| 2,529
|
import dayjs from "dayjs"
import updateLocale from "dayjs/plugin/updateLocale"
import localizedFormat from "dayjs/plugin/localizedFormat"
import relativeTime from "dayjs/esm/plugin/relativeTime"
import isToday from "dayjs/plugin/isToday"
import isYesterday from "dayjs/plugin/isYesterday"
import isBetween from "dayjs/plugin/isBetween"
dayjs.extend(updateLocale)
dayjs.extend(localizedFormat)
dayjs.extend(relativeTime)
dayjs.extend(isToday)
dayjs.extend(isYesterday)
dayjs.extend(isBetween)
export default dayjs
|
2302_79757062/hrms
|
frontend/src/utils/dayjs.js
|
JavaScript
|
agpl-3.0
| 515
|
export const showErrorAlert = async (message) => {
const alert = await alertController.create({
header: "Error",
message,
buttons: ["OK"],
})
await alert.present()
}
import { alertController } from "@ionic/vue"
|
2302_79757062/hrms
|
frontend/src/utils/dialogs.js
|
JavaScript
|
agpl-3.0
| 222
|
import { createDocumentResource } from "frappe-ui"
const settings = createDocumentResource({
doctype: "System Settings",
name: "System Settings",
auto: false,
})
export const formatCurrency = (value, currency) => {
if (!currency) return value
// hack: if value contains a space, it is already formatted
if (value?.toString().trim().includes(" ")) return value
const locale =
settings.doc?.country == "India" ? "en-IN" : settings.doc?.language
const formatter = Intl.NumberFormat(locale, {
style: "currency",
currency: currency,
trailingZeroDisplay: "stripIfInteger",
})
return (
formatter
.format(value)
// add space between the digits and symbol
.replace(/^(\D+)/, "$1 ")
// remove extra spaces if any (added by some browsers)
.replace(/\s+/, " ")
)
}
|
2302_79757062/hrms
|
frontend/src/utils/formatters.js
|
JavaScript
|
agpl-3.0
| 794
|
import { isPlatform } from "@ionic/vue"
import { createAnimation, iosTransitionAnimation } from "@ionic/core"
/**
* on iOS, the back swipe gesture triggers the animation twice:
* the safari's default back swipe animation & ionic's animation
* The config here takes care of the same
*/
export const animationBuilder = (baseEl, opts) => {
if (opts.direction === "back") {
/**
* Even after disabling swipeBackEnabled, when the swipe is completed & we're back on the first screen
* the "pop" animation is triggered, resulting in a double animation
* HACK: return empty animation for back swipe in ios
**/
return createAnimation()
}
return iosTransitionAnimation(baseEl, opts)
}
const getIonicConfig = () => {
const config = { mode: "ios" }
if (isPlatform("iphone")) {
// disable ionic's swipe back gesture on ios
config.swipeBackEnabled = false
config.navAnimation = animationBuilder
}
return config
}
export default getIonicConfig
|
2302_79757062/hrms
|
frontend/src/utils/ionicConfig.js
|
JavaScript
|
agpl-3.0
| 967
|
export const isChrome = () =>
navigator.userAgent.toLowerCase().includes("chrome")
export const showNotification = (payload) => {
const registration = window.frappePushNotification.serviceWorkerRegistration
if (!registration) return
const notificationTitle = payload?.data?.title
const notificationOptions = {
body: payload?.data?.body || "",
}
if (payload?.data?.notification_icon) {
notificationOptions["icon"] = payload.data.notification_icon
}
if (isChrome()) {
notificationOptions["data"] = {
url: payload?.data?.click_action,
}
} else {
if (payload?.data?.click_action) {
notificationOptions["actions"] = [
{
action: payload.data.click_action,
title: "View Details",
},
]
}
}
registration.showNotification(notificationTitle, notificationOptions)
}
|
2302_79757062/hrms
|
frontend/src/utils/pushNotifications.js
|
JavaScript
|
agpl-3.0
| 808
|
<template>
<ion-page>
<ion-content class="ion-padding">
<div class="flex flex-col h-screen w-screen">
<div class="w-full sm:w-96">
<header
class="flex flex-row bg-white shadow-sm py-4 px-3 items-center justify-between border-b sticky top-0 z-10"
>
<div class="flex flex-row items-center">
<Button
variant="ghost"
class="!pl-0 hover:bg-white"
@click="router.back()"
>
<FeatherIcon name="chevron-left" class="h-5 w-5" />
</Button>
<h2 class="text-xl font-semibold text-gray-900">Settings</h2>
</div>
</header>
<div class="flex flex-col gap-5 my-4 w-full p-4">
<div class="flex flex-col bg-white rounded">
<Switch
size="md"
label="Enable Push Notifications"
:class="description ? 'p-2' : ''"
:model-value="pushNotificationState"
:disabled="disablePushSetting"
:description="description"
@update:model-value="togglePushNotifications"
/>
</div>
<!-- Loading Indicator -->
<div
v-if="isLoading"
class="flex -mt-2 items-center justify-center gap-2"
>
<LoadingIndicator class="w-3 h-3 text-gray-800" />
<span class="text-gray-900 text-sm">
{{ pushNotificationState ? "Disabling" : "Enabling" }} Push
Notifications...
</span>
</div>
</div>
</div>
</div>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonPage, IonContent } from "@ionic/vue"
import { useRouter } from "vue-router"
import { FeatherIcon, Switch, toast, LoadingIndicator } from "frappe-ui"
import { computed, ref } from "vue"
import { arePushNotificationsEnabled } from "@/data/notifications"
const router = useRouter()
const pushNotificationState = ref(
window.frappePushNotification?.isNotificationEnabled()
)
const isLoading = ref(false)
const disablePushSetting = computed(() => {
return (
!(
window.frappe?.boot.push_relay_server_url &&
arePushNotificationsEnabled.data
) || isLoading.value
)
})
const description = computed(() => {
return !(
window.frappe?.boot.push_relay_server_url &&
arePushNotificationsEnabled.data
)
? "Push notifications have been disabled on your site"
: ""
})
const togglePushNotifications = (newValue) => {
if (newValue) {
enablePushNotifications()
} else {
isLoading.value = true
window.frappePushNotification
.disableNotification()
.then((data) => {
pushNotificationState.value = false // Disable the switch
// TODO: add commonfied toast util for success and error messages
toast({
title: "Success",
text: "Push notifications disabled",
icon: "check-circle",
position: "bottom-center",
iconClasses: "text-green-500",
})
})
.catch((error) => {
toast({
title: "Error",
text: error.message,
icon: "alert-circle",
position: "bottom-center",
iconClasses: "text-red-500",
})
})
.finally(() => {
isLoading.value = false
})
}
}
const enablePushNotifications = () => {
isLoading.value = true
window.frappePushNotification
.enableNotification()
.then((data) => {
if (data.permission_granted) {
pushNotificationState.value = true
} else {
toast({
title: "Error",
text: "Push Notification permission denied",
icon: "alert-circle",
position: "bottom-center",
iconClasses: "text-red-500",
})
pushNotificationState.value = false
}
})
.catch((error) => {
toast({
title: "Error",
text: error.message,
icon: "alert-circle",
position: "bottom-center",
iconClasses: "text-red-500",
})
pushNotificationState.value = false
})
.finally(() => {
isLoading.value = false
})
}
</script>
|
2302_79757062/hrms
|
frontend/src/views/AppSettings.vue
|
Vue
|
agpl-3.0
| 3,783
|
<template>
<BaseLayout>
<template #body>
<div class="flex flex-col items-center my-7 p-4 gap-7">
<CheckInPanel />
<QuickLinks :items="quickLinks" title="Quick Links" />
<RequestPanel />
</div>
</template>
</BaseLayout>
</template>
<script setup>
import { markRaw } from "vue"
import CheckInPanel from "@/components/CheckInPanel.vue"
import QuickLinks from "@/components/QuickLinks.vue"
import BaseLayout from "@/components/BaseLayout.vue"
import RequestPanel from "@/components/RequestPanel.vue"
import LeaveIcon from "@/components/icons/LeaveIcon.vue"
import ExpenseIcon from "@/components/icons/ExpenseIcon.vue"
import EmployeeAdvanceIcon from "@/components/icons/EmployeeAdvanceIcon.vue"
import SalaryIcon from "@/components/icons/SalaryIcon.vue"
const quickLinks = [
{
icon: markRaw(LeaveIcon),
title: "Request Leave",
route: "LeaveApplicationFormView",
},
{
icon: markRaw(ExpenseIcon),
title: "Claim an Expense",
route: "ExpenseClaimFormView",
},
{
icon: markRaw(EmployeeAdvanceIcon),
title: "Request an Advance",
route: "EmployeeAdvanceFormView",
},
{
icon: markRaw(SalaryIcon),
title: "View Salary Slips",
route: "SalarySlipsDashboard",
},
]
</script>
|
2302_79757062/hrms
|
frontend/src/views/Home.vue
|
Vue
|
agpl-3.0
| 1,218
|
<template>
<ion-page>
<ion-content class="ion-padding">
<div class="flex h-screen w-screen flex-col justify-center bg-white">
<Dialog
:options="{
title: 'Login Failed',
message: `No active employee found associated with the email ID ${session?.user}. Try logging in with your employee email ID or contact your HR manager for access.`,
size: 'lg',
actions: [
{
label: 'Go to Login',
variant: 'solid',
onClick: () => session.logout.submit(),
},
],
}"
v-model="showDialog"
@close="
() => {
session.logout.submit()
showDialog = false
}
"
/>
</div>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonPage, IonContent } from "@ionic/vue"
import { inject, ref } from "vue"
import { Dialog } from "frappe-ui"
const session = inject("$session")
const showDialog = ref(true)
</script>
|
2302_79757062/hrms
|
frontend/src/views/InvalidEmployee.vue
|
Vue
|
agpl-3.0
| 931
|
<template>
<ion-page>
<ion-content class="ion-padding">
<div class="flex h-screen w-screen flex-col justify-center bg-white">
<div class="flex flex-col mx-auto gap-3 items-center">
<FrappeHRLogo class="h-8 w-8" />
<div class="text-3xl font-semibold text-gray-900 text-center">Login to Frappe HR</div>
</div>
<div class="mx-auto mt-10 w-full px-8 sm:w-96">
<form class="flex flex-col space-y-4" @submit.prevent="submit">
<Input
label="Email"
placeholder="johndoe@mail.com"
v-model="email"
type="text"
autocomplete="username"
/>
<Input
label="Password"
type="password"
placeholder="••••••"
v-model="password"
autocomplete="current-password"
/>
<ErrorMessage :message="errorMessage" />
<Button
:loading="session.login.loading"
variant="solid"
class="disabled:bg-gray-700 disabled:text-white !mt-6"
>
Login
</Button>
</form>
</div>
</div>
<Dialog v-model="resetPassword.showDialog">
<template #body-title>
<h2 class="text-lg font-bold">Reset Password</h2>
</template>
<template #body-content>
<p>Your password has expired. Please reset your password to continue</p>
</template>
<template #actions>
<a
class="inline-flex items-center justify-center gap-2 transition-colors focus:outline-none text-white bg-gray-900 hover:bg-gray-800 active:bg-gray-700 focus-visible:ring focus-visible:ring-gray-400 h-7 text-base px-2 rounded"
:href="resetPassword.link"
target="_blank"
>
Go to Reset Password page
</a>
</template>
</Dialog>
<Dialog v-model="otp.showDialog">
<template #body-title>
<h2 class="text-lg font-bold">OTP Verification</h2>
</template>
<template #body-content>
<p class="mb-4" v-if="otp.verification.prompt">
{{ otp.verification.prompt }}
</p>
<form class="flex flex-col space-y-4" @submit.prevent="submit">
<Input
label="OTP Code"
type="text"
placeholder="000000"
v-model="otp.code"
autocomplete="one-time-code"
/>
<ErrorMessage :message="errorMessage" />
<Button
:loading="session.otp.loading"
variant="solid"
class="disabled:bg-gray-700 disabled:text-white !mt-6"
>
Verify
</Button>
</form>
</template>
</Dialog>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonPage, IonContent } from "@ionic/vue"
import { inject, reactive, ref } from "vue"
import { Input, Button, ErrorMessage, Dialog } from "frappe-ui"
import FrappeHRLogo from "@/components/icons/FrappeHRLogo.vue"
const email = ref(null)
const password = ref(null)
const errorMessage = ref("")
const resetPassword = reactive({
showDialog: false,
link: "",
})
const otp = reactive({
showDialog: false,
tmp_id: "",
code: "",
verification: {},
})
const session = inject("$session")
async function submit(e) {
try {
let response
if (otp.showDialog) {
response = await session.otp(otp.tmp_id, otp.code)
} else {
response = await session.login(email.value, password.value)
}
if (response.message === "Password Reset") {
resetPassword.showDialog = true
resetPassword.link = response.redirect_to
} else {
resetPassword.showDialog = false
resetPassword.link = ""
}
// OTP verification
if (response.verification) {
if (response.verification.setup) {
otp.showDialog = true
otp.tmp_id = response.tmp_id
otp.verification = response.verification
} else {
// Don't bother handling impossible OTP setup (e.g. no phone number).
window.open("/login?redirect-to=" + encodeURIComponent(window.location.pathname), "_blank")
}
}
} catch (error) {
errorMessage.value = error.messages.join("\n")
}
}
</script>
|
2302_79757062/hrms
|
frontend/src/views/Login.vue
|
Vue
|
agpl-3.0
| 3,894
|
<template>
<ion-page>
<ion-content class="ion-padding">
<div class="flex flex-col h-screen w-screen">
<div class="w-full sm:w-96">
<header
class="flex flex-row bg-white shadow-sm py-4 px-3 items-center justify-between border-b sticky top-0 z-10"
>
<div class="flex flex-row items-center">
<Button
variant="ghost"
class="!pl-0 hover:bg-white"
@click="router.back()"
>
<FeatherIcon name="chevron-left" class="h-5 w-5" />
</Button>
<h2 class="text-xl font-semibold text-gray-900">Notifications</h2>
</div>
</header>
<div class="flex flex-col gap-4 mt-5 p-4">
<div class="flex flex-row justify-between items-center">
<div
class="text-lg text-gray-800 font-semibold"
v-if="unreadNotificationsCount.data"
>
{{ unreadNotificationsCount.data }} Unread
</div>
<div class="flex ml-auto gap-1">
<Button
v-if="allowPushNotifications"
variant="outline"
@click="router.push({ name: 'Settings' })"
>
<template #prefix>
<FeatherIcon name="settings" class="w-4" />
</template>
Settings
</Button>
<Button
v-if="unreadNotificationsCount.data"
variant="outline"
@click="markAllAsRead.submit"
:loading="markAllAsRead.loading"
>
<template #prefix>
<FeatherIcon name="check-circle" class="w-4" />
</template>
Mark all as read
</Button>
</div>
</div>
<div
class="flex flex-col bg-white rounded"
v-if="notifications.data?.length"
>
<router-link
:class="[
'flex flex-row items-start p-4 justify-between border-b before:mt-3',
`before:content-[''] before:mr-2 before:shrink-0 before:w-1.5 before:h-1.5 before:rounded-full`,
item.read ? 'bg-white-500' : 'before:bg-blue-500',
]"
v-for="item in notifications.data"
:key="item.name"
:to="getItemRoute(item)"
@click="markAsRead(item.name)"
>
<EmployeeAvatar :userID="item.from_user" size="lg" />
<div class="flex flex-col gap-0.5 grow ml-3">
<div
class="text-sm leading-5 font-normal text-gray-800"
v-html="item.message"
></div>
<div class="text-xs font-normal text-gray-500">
{{ dayjs(item.creation).fromNow() }}
</div>
</div>
</router-link>
</div>
<EmptyState v-else message="You have no notifications" />
</div>
</div>
</div>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonContent, IonPage } from "@ionic/vue"
import { useRouter } from "vue-router"
import { createResource, FeatherIcon } from "frappe-ui"
import { computed, inject } from "vue"
import EmployeeAvatar from "@/components/EmployeeAvatar.vue"
import EmptyState from "@/components/EmptyState.vue"
import {
unreadNotificationsCount,
notifications,
arePushNotificationsEnabled,
} from "@/data/notifications"
const user = inject("$user")
const dayjs = inject("$dayjs")
const router = useRouter()
const allowPushNotifications = computed(
() =>
window.frappe?.boot.push_relay_server_url &&
arePushNotificationsEnabled.data
)
const markAllAsRead = createResource({
url: "hrms.api.mark_all_notifications_as_read",
onSuccess() {
notifications.reload()
},
})
function markAsRead(name) {
notifications.setValue.submit(
{ name, read: 1 },
{
onSuccess: () => {
unreadNotificationsCount.reload()
},
}
)
}
function getItemRoute(item) {
return {
name: `${item.reference_document_type.replace(/\s+/g, "")}DetailView`,
params: { id: item.reference_document_name },
}
}
</script>
|
2302_79757062/hrms
|
frontend/src/views/Notifications.vue
|
Vue
|
agpl-3.0
| 3,815
|
<template>
<ion-page>
<ion-content class="ion-padding">
<div class="flex flex-col h-screen w-screen">
<div class="w-full sm:w-96">
<header
class="flex flex-row bg-white shadow-sm py-4 px-3 items-center justify-between border-b sticky top-0 z-10"
>
<div class="flex flex-row items-center">
<Button
variant="ghost"
class="!pl-0 hover:bg-white"
@click="router.back()"
>
<FeatherIcon name="chevron-left" class="h-5 w-5" />
</Button>
<h2 class="text-xl font-semibold text-gray-900">Profile</h2>
</div>
</header>
<div class="flex flex-col items-center mt-5 p-4">
<!-- Profile Image -->
<img
v-if="user.data.user_image"
class="h-24 w-24 rounded-full object-cover"
:src="user.data.user_image"
:alt="user.data.first_name"
/>
<div
v-else
class="flex items-center justify-center bg-gray-200 uppercase text-gray-600 h-24 w-24 rounded-full object-cover"
>
{{ user.data.first_name[0] }}
</div>
<div class="flex flex-col gap-1.5 items-center mt-2 mb-5">
<span v-if="employee" class="text-lg font-bold text-gray-900">{{
employee?.data?.employee_name
}}</span>
<span v-if="employee" class="font-normal text-sm text-gray-500">{{
employee?.data?.designation
}}</span>
</div>
<!-- Profile Links -->
<div class="flex flex-col gap-5 my-4 w-full">
<div class="flex flex-col bg-white rounded">
<div
class="flex flex-row cursor-pointer flex-start p-4 items-center justify-between border-b"
v-for="link in profileLinks"
:key="link.title"
@click="openInfoModal(link)"
>
<div class="flex flex-row items-center gap-3 grow">
<FeatherIcon
:name="link.icon"
class="h-5 w-5 text-gray-500"
/>
<div class="text-base font-normal text-gray-800">
{{ link.title }}
</div>
</div>
<FeatherIcon
name="chevron-right"
class="h-5 w-5 text-gray-500"
/>
</div>
</div>
</div>
<!-- Settings -->
<div
class="flex flex-col gap-5 my-4 w-full"
v-if="allowPushNotifications"
>
<div class="flex flex-col bg-white rounded">
<router-link
:to="{ name: 'Settings' }"
class="flex flex-row cursor-pointer flex-start p-4 items-center justify-between border-b"
>
<div class="flex flex-row items-center gap-3 grow">
<FeatherIcon
name="settings"
class="h-5 w-5 text-gray-500"
/>
<div class="text-base font-normal text-gray-800">
Settings
</div>
</div>
<FeatherIcon
name="chevron-right"
class="h-5 w-5 text-gray-500"
/>
</router-link>
</div>
</div>
<Button
@click="logout"
variant="outline"
theme="red"
class="w-full shadow py-4 mt-5"
>
<template #prefix>
<FeatherIcon name="log-out" class="w-4" />
</template>
Log Out
</Button>
</div>
</div>
</div>
<ion-modal
ref="modal"
:is-open="isInfoModalOpen"
@didDismiss="closeInfoModal"
:initial-breakpoint="1"
:breakpoints="[0, 1]"
>
<ProfileInfoModal
:title="selectedItem.title"
:data="
selectedItem.fields.map((field) => {
const [label, fieldtype] = getFieldInfo(field)
return {
fieldname: field,
value: employeeDoc.doc[field],
label: label,
fieldtype: fieldtype,
}
})
"
/>
</ion-modal>
</ion-content>
</ion-page>
</template>
<script setup>
import { computed, inject, ref, onMounted, onBeforeUnmount } from "vue"
import { useRouter } from "vue-router"
import { IonModal, IonPage, IonContent } from "@ionic/vue"
import { FeatherIcon, createDocumentResource, createResource } from "frappe-ui"
import { showErrorAlert } from "@/utils/dialogs"
import { formatCurrency } from "@/utils/formatters"
import ProfileInfoModal from "@/components/ProfileInfoModal.vue"
import { arePushNotificationsEnabled } from "@/data/notifications"
const DOCTYPE = "Employee"
const socket = inject("$socket")
const session = inject("$session")
const user = inject("$user")
const employee = inject("$employee")
const router = useRouter()
const profileLinks = [
{
icon: "user",
title: "Employee Details",
fields: [
"employee_name",
"employee_number",
"gender",
"date_of_birth",
"date_of_joining",
"blood_group",
],
},
{
icon: "file",
title: "Company Information",
fields: [
"company",
"department",
"designation",
"branch",
"grade",
"reports_to",
"employment_type",
],
},
{
icon: "book",
title: "Contact Information",
fields: [
"cell_number",
"personal_email",
"company_email",
"preferred_email",
],
},
{
icon: "dollar-sign",
title: "Salary Information",
fields: [
"ctc",
"payroll_cost_center",
"pan_number",
"provident_fund_account",
"salary_mode",
"bank_name",
"bank_ac_no",
"ifsc_code",
"micr_code",
"iban",
],
},
]
const isInfoModalOpen = ref(false)
const selectedItem = ref(null)
const allowPushNotifications = computed(
() =>
window.frappe?.boot.push_relay_server_url &&
arePushNotificationsEnabled.data
)
const openInfoModal = async (request) => {
selectedItem.value = request
isInfoModalOpen.value = true
}
const closeInfoModal = async (_request) => {
isInfoModalOpen.value = false
selectedItem.value = null
}
const employeeDoc = createDocumentResource({
doctype: DOCTYPE,
name: employee.data.name,
fields: "*",
auto: true,
transform: (data) => {
data.ctc = formatCurrency(data.ctc, data.salary_currency)
return data
},
})
const employeeDocType = createResource({
url: "hrms.api.get_doctype_fields",
params: { doctype: DOCTYPE },
auto: true,
})
const getFieldInfo = (fieldname) => {
const field = employeeDocType.data.find(
(field) => field.fieldname === fieldname
)
return [field?.label, field?.fieldtype]
}
const logout = async () => {
try {
await session.logout.submit()
} catch (e) {
const msg = "An error occurred while attempting to log out!"
console.error(msg, e)
showErrorAlert(msg)
}
}
onMounted(() => {
socket.emit("doctype_subscribe", DOCTYPE)
socket.on("list_update", (data) => {
if (data.doctype === DOCTYPE && data.name === employee.data.name) {
employeeDoc.reload()
}
})
})
onBeforeUnmount(() => {
socket.emit("doctype_unsubscribe", DOCTYPE)
socket.off("list_update")
})
</script>
|
2302_79757062/hrms
|
frontend/src/views/Profile.vue
|
Vue
|
agpl-3.0
| 6,751
|
<template>
<ion-page>
<ion-tabs>
<ion-router-outlet></ion-router-outlet>
<BottomTabs />
</ion-tabs>
</ion-page>
</template>
<script setup>
import { IonTabs, IonPage, IonRouterOutlet } from "@ionic/vue"
import BottomTabs from "@/components/BottomTabs.vue"
</script>
|
2302_79757062/hrms
|
frontend/src/views/TabbedView.vue
|
Vue
|
agpl-3.0
| 278
|
<template>
<ion-page>
<ion-content :fullscreen="true">
<FormView
v-if="formFields.data"
doctype="Employee Advance"
v-model="employeeAdvance"
:isSubmittable="true"
:fields="formFields.data"
:id="props.id"
:showAttachmentView="true"
@validateForm="validateForm"
/>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonPage, IonContent } from "@ionic/vue"
import { createResource } from "frappe-ui"
import { ref, watch, inject, computed } from "vue"
import FormView from "@/components/FormView.vue"
import { getCompanyCurrency } from "@/data/currencies"
const employee = inject("$employee")
const props = defineProps({
id: {
type: String,
required: false,
},
})
// object to store form data
const employeeAdvance = ref({
employee: employee.data.name,
employee_name: employee.data.employee_name,
company: employee.data.company,
department: employee.data.department,
})
const companyCurrency = computed(() =>
getCompanyCurrency(employeeAdvance.value.company)
)
// get form fields
const formFields = createResource({
url: "hrms.api.get_doctype_fields",
params: { doctype: "Employee Advance" },
transform(data) {
const fields = getFilteredFields(data)
return applyFilters(fields)
},
onSuccess(_) {
employeeCurrency.reload()
advanceAccount.reload()
},
})
formFields.reload()
const employeeCurrency = createResource({
url: "hrms.payroll.doctype.salary_structure_assignment.salary_structure_assignment.get_employee_currency",
params: { employee: employee.data.name },
onSuccess(data) {
employeeAdvance.value.currency = data
setExchangeRate()
},
})
const exchangeRate = createResource({
url: "erpnext.setup.utils.get_exchange_rate",
onSuccess(data) {
employeeAdvance.value.exchange_rate = data
},
})
const advanceAccount = createResource({
url: "hrms.api.get_advance_account",
params: { company: employeeAdvance.value.company },
onSuccess(data) {
employeeAdvance.value.advance_account = data
},
})
// form scripts
watch(
() => employeeAdvance.value.currency,
() => setExchangeRate()
)
// helper functions
function getFilteredFields(fields) {
// reduce noise from the form view by excluding unnecessary fields
// eg: employee and other details can be fetched from the session user
const excludeFields = ["naming_series"]
const extraFields = [
"employee",
"employee_name",
"department",
"company",
"more_info_section",
"pending_amount",
]
if (!props.id) excludeFields.push(...extraFields)
return fields.filter((field) => !excludeFields.includes(field.fieldname))
}
function applyFilters(fields) {
return fields.map((field) => {
if (field.fieldname === "advance_account") {
let currencies = [employeeAdvance.value.currency]
if (employeeAdvance.value.currency != companyCurrency.value)
currencies.push(companyCurrency.value)
field.linkFilters = {
company: employeeAdvance.value.company,
is_group: 0,
root_type: "Asset",
account_currency: ("in", currencies),
}
}
return field
})
}
function setExchangeRate() {
if (!employeeAdvance.value.currency) return
const exchange_rate_field = formFields.data?.find(
(field) => field.fieldname === "exchange_rate"
)
if (employeeAdvance.value.currency === companyCurrency.value) {
employeeAdvance.value.exchange_rate = 1
exchange_rate_field.hidden = 1
} else {
exchangeRate.fetch({
from_currency: employeeAdvance.value.currency,
to_currency: companyCurrency.value,
})
exchange_rate_field.hidden = 0
}
}
function validateForm() {}
</script>
|
2302_79757062/hrms
|
frontend/src/views/employee_advance/Form.vue
|
Vue
|
agpl-3.0
| 3,568
|
<template>
<ion-page>
<ListView
doctype="Employee Advance"
pageTitle="Employee Advances"
:tabButtons="TAB_BUTTONS"
:fields="EMPLOYEE_ADVANCE_FIELDS"
:filterConfig="FILTER_CONFIG"
/>
</ion-page>
</template>
<script setup>
import { IonPage } from "@ionic/vue"
import ListView from "@/components/ListView.vue"
const TAB_BUTTONS = ["My Advances", "Team Advances"]
const EMPLOYEE_ADVANCE_FIELDS = [
"name",
"employee",
"employee_name",
"status",
"purpose",
"advance_amount",
"paid_amount",
"claimed_amount",
"return_amount",
"posting_date",
"currency",
]
const STATUS_FILTER_OPTIONS = [
"Draft",
"Paid",
"Unpaid",
"Claimed",
"Returned",
"Partly Claimed and Returned",
"Cancelled",
]
const FILTER_CONFIG = [
{
fieldname: "status",
fieldtype: "Select",
label: "Status",
options: STATUS_FILTER_OPTIONS,
},
{
fieldname: "employee",
fieldtype: "Link",
label: "Employee",
options: "Employee",
},
{
fieldname: "department",
fieldtype: "Link",
label: "Department",
options: "Department",
},
{ fieldname: "posting_date", fieldtype: "Date", label: "Posting Date" },
{
fieldname: "advance_amount",
fieldtype: "Currency",
label: "Advance Amount",
},
{ fieldname: "paid_amount", fieldtype: "Currency", label: "Paid Amount" },
]
</script>
|
2302_79757062/hrms
|
frontend/src/views/employee_advance/List.vue
|
Vue
|
agpl-3.0
| 1,302
|
<template>
<BaseLayout pageTitle="Expense Claims">
<template #body>
<div class="flex flex-col mt-7 mb-7 p-4 gap-7">
<ExpenseClaimSummary />
<div class="w-full">
<router-link
:to="{ name: 'ExpenseClaimFormView' }"
v-slot="{ navigate }"
>
<Button
@click="navigate"
variant="solid"
class="w-full py-5 text-base"
>
Claim an Expense
</Button>
</router-link>
</div>
<div>
<div class="text-lg text-gray-800 font-bold">Recent Expenses</div>
<RequestList
:component="markRaw(ExpenseClaimItem)"
:items="myClaims.data"
:addListButton="true"
listButtonRoute="ExpenseClaimListView"
/>
</div>
<div>
<div class="flex flex-row justify-between items-center">
<div class="text-lg text-gray-800 font-bold">
Employee Advance Balance
</div>
<router-link
:to="{ name: 'EmployeeAdvanceListView' }"
class="text-sm text-gray-800 font-semibold cursor-pointer underline underline-offset-2"
>
View List
</router-link>
</div>
<EmployeeAdvanceBalance :items="advanceBalance.data" />
</div>
</div>
</template>
</BaseLayout>
</template>
<script setup>
import { markRaw } from "vue"
import BaseLayout from "@/components/BaseLayout.vue"
import ExpenseClaimSummary from "@/components/ExpenseClaimSummary.vue"
import RequestList from "@/components/RequestList.vue"
import ExpenseClaimItem from "@/components/ExpenseClaimItem.vue"
import EmployeeAdvanceBalance from "@/components/EmployeeAdvanceBalance.vue"
import { myClaims } from "@/data/claims"
import { advanceBalance } from "@/data/advances"
</script>
|
2302_79757062/hrms
|
frontend/src/views/expense_claim/Dashboard.vue
|
Vue
|
agpl-3.0
| 1,703
|
<template>
<ion-page>
<ion-content :fullscreen="true">
<FormView
v-if="formFields.data"
doctype="Expense Claim"
v-model="expenseClaim"
:isSubmittable="true"
:fields="formFields.data"
:id="props.id"
:tabbedView="true"
:tabs="tabs"
:showAttachmentView="true"
@validateForm="validateForm"
>
<!-- Child Tables -->
<template #expenses="{ isFormReadOnly }">
<ExpensesTable
v-model:expenseClaim="expenseClaim"
:currency="currency"
:isReadOnly="isReadOnly || isFormReadOnly"
@addExpenseItem="addExpenseItem"
@updateExpenseItem="updateExpenseItem"
@deleteExpenseItem="deleteExpenseItem"
/>
</template>
<template #taxes="{ isFormReadOnly }">
<ExpenseTaxesTable
v-model:expenseClaim="expenseClaim"
:currency="currency"
:isReadOnly="isReadOnly || isFormReadOnly"
@addExpenseTax="addExpenseTax"
@updateExpenseTax="updateExpenseTax"
@deleteExpenseTax="deleteExpenseTax"
/>
</template>
<template #advances="{ isFormReadOnly }">
<ExpenseAdvancesTable
v-model:expenseClaim="expenseClaim"
:currency="currency"
:isReadOnly="isReadOnly || isFormReadOnly"
/>
</template>
</FormView>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonPage, IonContent } from "@ionic/vue"
import { createResource } from "frappe-ui"
import { computed, ref, watch, inject } from "vue"
import FormView from "@/components/FormView.vue"
import ExpensesTable from "@/components/ExpensesTable.vue"
import ExpenseTaxesTable from "@/components/ExpenseTaxesTable.vue"
import ExpenseAdvancesTable from "@/components/ExpenseAdvancesTable.vue"
import { getCompanyCurrency } from "@/data/currencies"
const dayjs = inject("$dayjs")
const employee = inject("$employee")
const today = dayjs().format("YYYY-MM-DD")
const isReadOnly = ref(false)
const props = defineProps({
id: {
type: String,
required: false,
},
})
const tabs = [
{ name: "Expenses", lastField: "taxes" },
{ name: "Advances", lastField: "advances" },
{ name: "Totals", lastField: "cost_center" },
]
// object to store form data
const expenseClaim = ref({
employee: employee.data.name,
company: employee.data.company,
})
const currency = computed(() => getCompanyCurrency(expenseClaim.value.company))
// get form fields
const formFields = createResource({
url: "hrms.api.get_doctype_fields",
params: { doctype: "Expense Claim" },
transform(data) {
let fields = getFilteredFields(data)
return fields.map((field) => {
if (field.fieldname === "posting_date") field.default = today
return applyFilters(field)
})
},
onSuccess(_data) {
expenseApproverDetails.reload()
companyDetails.reload()
},
})
formFields.reload()
// resources
const advances = createResource({
url: "hrms.hr.doctype.expense_claim.expense_claim.get_advances",
params: { employee: employee.data.name },
auto: true,
onSuccess(data) {
// set advances
if (props.id) {
expenseClaim.value.advances?.map((advance) => (advance.selected = true))
} else {
expenseClaim.value.advances = []
}
return data.forEach((advance) => {
if (
props.id &&
expenseClaim.value.advances?.some(
(entry) => entry.employee_advance === advance.name
)
)
return
expenseClaim.value.advances?.push({
employee_advance: advance.name,
purpose: advance.purpose,
posting_date: advance.posting_date,
advance_account: advance.advance_account,
advance_paid: advance.paid_amount,
unclaimed_amount: advance.paid_amount - advance.claimed_amount,
allocated_amount: 0,
})
})
},
})
const expenseApproverDetails = createResource({
url: "hrms.api.get_expense_approval_details",
params: { employee: employee.data.name },
onSuccess(data) {
setExpenseApprover(data)
},
})
const companyDetails = createResource({
url: "hrms.api.get_company_cost_center_and_expense_account",
params: { company: expenseClaim.value.company },
onSuccess(data) {
expenseClaim.value.cost_center = data?.cost_center
expenseClaim.value.payable_account =
data?.default_expense_claim_payable_account
},
})
// form scripts
watch(
() => expenseClaim.value.employee,
(employee_id) => {
if (props.id && employee_id !== employee.data.name) {
// if employee is not the current user, set form as read only
setFormReadOnly()
}
}
)
watch(
() => props.id && expenseClaim.value.expenses,
(_) => {
if (expenseClaim.value.docstatus === 0) {
advances.reload()
}
}
)
watch(
() => expenseClaim.value.advances,
(_value) => {
calculateTotalAdvance()
},
{ deep: true }
)
watch(
() => expenseClaim.value.cost_center,
() => {
expenseClaim?.value?.expenses?.forEach((expense) => {
expense.cost_center = expenseClaim.value.cost_center
})
}
)
// helper functions
function getFilteredFields(fields) {
// reduce noise from the form view by excluding unnecessary fields
// eg: employee and other details can be fetched from the session user
const excludeFields = [
"naming_series",
"task",
"taxes_and_charges_sb",
"advance_payments_sb",
]
const extraFields = [
"employee",
"employee_name",
"department",
"company",
"remark",
"is_paid",
"mode_of_payment",
"clearance_date",
"approval_status",
]
if (!props.id) excludeFields.push(...extraFields)
return fields.filter((field) => !excludeFields.includes(field.fieldname))
}
function applyFilters(field) {
if (field.fieldname === "payable_account") {
field.linkFilters = {
report_type: "Balance Sheet",
account_type: "Payable",
company: expenseClaim.value.company,
is_group: 0,
}
} else if (field.fieldname === "cost_center") {
field.linkFilters = {
company: expenseClaim.value.company,
is_group: 0,
}
} else if (field.fieldname === "project") {
field.linkFilters = {
company: expenseClaim.value.company,
}
}
return field
}
function setExpenseApprover(data) {
const expense_approver = formFields.data?.find(
(field) => field.fieldname === "expense_approver"
)
expense_approver.reqd = data?.is_mandatory
expense_approver.documentList = data?.department_approvers.map(
(approver) => ({
label: approver.full_name
? `${approver.name} : ${approver.full_name}`
: approver.name,
value: approver.name,
})
)
expenseClaim.value.expense_approver = data?.expense_approver
expenseClaim.value.expense_approver_name = data?.expense_approver_name
}
function addExpenseItem(item) {
if (!expenseClaim.value.expenses) expenseClaim.value.expenses = []
expenseClaim.value.expenses.push(item)
calculateTotals()
calculateTaxes()
allocateAdvanceAmount()
}
function updateExpenseItem(item, idx) {
expenseClaim.value.expenses[idx] = item
calculateTotals()
calculateTaxes()
allocateAdvanceAmount()
}
function deleteExpenseItem(idx) {
expenseClaim.value.expenses.splice(idx, 1)
calculateTotals()
calculateTaxes()
allocateAdvanceAmount()
}
function addExpenseTax(item) {
if (!expenseClaim.value.taxes) expenseClaim.value.taxes = []
expenseClaim.value.taxes.push(item)
calculateTaxes()
allocateAdvanceAmount()
}
function updateExpenseTax(item, idx) {
expenseClaim.value.taxes[idx] = item
calculateTaxes()
allocateAdvanceAmount()
}
function deleteExpenseTax(idx) {
expenseClaim.value.taxes.splice(idx, 1)
calculateTaxes()
allocateAdvanceAmount()
}
function calculateTotals() {
let total_claimed_amount = 0
let total_sanctioned_amount = 0
expenseClaim.value?.expenses?.forEach((item) => {
total_claimed_amount += parseFloat(item.amount)
total_sanctioned_amount += parseFloat(item.sanctioned_amount)
})
expenseClaim.value.total_claimed_amount = total_claimed_amount
expenseClaim.value.total_sanctioned_amount = total_sanctioned_amount
calculateGrandTotal()
}
function calculateTaxes() {
let total_taxes_and_charges = 0
expenseClaim.value?.taxes?.forEach((item) => {
if (item.rate) {
item.tax_amount =
parseFloat(expenseClaim.value.total_sanctioned_amount) *
parseFloat(item.rate / 100)
}
item.total =
parseFloat(item.tax_amount) +
parseFloat(expenseClaim.value.total_sanctioned_amount)
total_taxes_and_charges += parseFloat(item.tax_amount)
})
expenseClaim.value.total_taxes_and_charges = total_taxes_and_charges
calculateGrandTotal()
}
function calculateGrandTotal() {
expenseClaim.value.grand_total =
parseFloat(expenseClaim.value.total_sanctioned_amount || 0) +
parseFloat(expenseClaim.value.total_taxes_and_charges || 0) -
parseFloat(expenseClaim.value.total_advance_amount || 0)
}
function allocateAdvanceAmount() {
// allocate reqd advance amount
let amount_to_be_allocated =
parseFloat(expenseClaim.value.total_sanctioned_amount) +
parseFloat(expenseClaim.value.total_taxes_and_charges)
let total_advance_amount = 0
expenseClaim?.value?.advances?.forEach((advance) => {
if (amount_to_be_allocated >= parseFloat(advance.unclaimed_amount)) {
advance.allocated_amount = parseFloat(advance.unclaimed_amount)
amount_to_be_allocated -= parseFloat(advance.allocated_amount)
} else {
advance.allocated_amount = amount_to_be_allocated
amount_to_be_allocated = 0
}
advance.selected = advance.allocated_amount > 0 ? true : false
total_advance_amount += parseFloat(advance.allocated_amount)
})
expenseClaim.value.total_advance_amount = total_advance_amount
calculateGrandTotal()
}
function calculateTotalAdvance() {
// update total advance amount as per user selection & edited values
let total_advance_amount = 0
expenseClaim?.value?.advances?.forEach((advance) => {
if (advance.selected) {
total_advance_amount += parseFloat(advance.allocated_amount)
}
})
expenseClaim.value.total_advance_amount = total_advance_amount
calculateGrandTotal()
}
function setFormReadOnly() {
if (expenseClaim.value.expense_approver === employee.data.user_id) return
formFields.data.map((field) => (field.read_only = true))
isReadOnly.value = true
}
function validateForm() {
// set selected advances
if (!expenseClaim?.value?.advances) return
expenseClaim.value.advances = expenseClaim?.value?.advances?.filter(
(advance) => advance.selected
)
expenseClaim?.value?.expenses?.forEach((expense) => {
expense.cost_center = expenseClaim.value.cost_center
})
}
</script>
|
2302_79757062/hrms
|
frontend/src/views/expense_claim/Form.vue
|
Vue
|
agpl-3.0
| 10,289
|
<template>
<ion-page>
<ListView
doctype="Expense Claim"
pageTitle="Claim History"
:tabButtons="TAB_BUTTONS"
:fields="EXPENSE_CLAIM_FIELDS"
groupBy="`tabExpense Claim`.name"
:filterConfig="FILTER_CONFIG"
/>
</ion-page>
</template>
<script setup>
import { IonPage } from "@ionic/vue"
import ListView from "@/components/ListView.vue"
const TAB_BUTTONS = ["My Claims", "Team Claims"]
const EXPENSE_CLAIM_FIELDS = [
"`tabExpense Claim`.name",
"`tabExpense Claim`.employee",
"`tabExpense Claim`.employee_name",
"`tabExpense Claim`.approval_status",
"`tabExpense Claim`.status",
"`tabExpense Claim`.expense_approver",
"`tabExpense Claim`.total_claimed_amount",
"`tabExpense Claim`.posting_date",
"`tabExpense Claim`.company",
"`tabExpense Claim Detail`.expense_type",
"count(`tabExpense Claim Detail`.expense_type) as total_expenses",
]
const FILTER_CONFIG = [
{
fieldname: "approval_status",
fieldtype: "Select",
label: "Approval Status",
options: ["Draft", "Approved", "Rejected"],
},
{
fieldname: "status",
fieldtype: "Select",
label: "Status",
options: ["Draft", "Paid", "Unpaid", "Rejected", "Submitted", "Cancelled"],
},
{
fieldname: "employee",
fieldtype: "Link",
label: "Employee",
options: "Employee",
},
{
fieldname: "department",
fieldtype: "Link",
label: "Department",
options: "Department",
},
{ fieldname: "posting_date", fieldtype: "Date", label: "Posting Date" },
]
</script>
|
2302_79757062/hrms
|
frontend/src/views/expense_claim/List.vue
|
Vue
|
agpl-3.0
| 1,464
|
<template>
<BaseLayout pageTitle="Leaves & Holidays">
<template #body>
<div class="flex flex-col items-center mt-7 mb-7 py-4">
<LeaveBalance />
<div class="flex flex-col gap-7 mt-5 px-4 w-full">
<router-link
:to="{ name: 'LeaveApplicationFormView' }"
v-slot="{ navigate }"
>
<Button
@click="navigate"
variant="solid"
class="py-5 text-base w-full"
>
Request a Leave
</Button>
</router-link>
<div>
<div class="text-lg text-gray-800 font-bold">Recent Leaves</div>
<RequestList
:component="markRaw(LeaveRequestItem)"
:items="myLeaves.data"
:addListButton="true"
listButtonRoute="LeaveApplicationListView"
/>
</div>
<Holidays />
</div>
</div>
</template>
</BaseLayout>
</template>
<script setup>
import { markRaw } from "vue"
import BaseLayout from "@/components/BaseLayout.vue"
import LeaveBalance from "@/components/LeaveBalance.vue"
import RequestList from "@/components/RequestList.vue"
import LeaveRequestItem from "@/components/LeaveRequestItem.vue"
import Holidays from "@/components/Holidays.vue"
import { myLeaves } from "@/data/leaves"
</script>
|
2302_79757062/hrms
|
frontend/src/views/leave/Dashboard.vue
|
Vue
|
agpl-3.0
| 1,217
|
<template>
<ion-page>
<ion-content :fullscreen="true">
<FormView
v-if="formFields.data"
doctype="Leave Application"
v-model="leaveApplication"
:isSubmittable="true"
:fields="formFields.data"
:id="props.id"
:showAttachmentView="true"
@validateForm="validateForm"
/>
</ion-content>
</ion-page>
</template>
<script setup>
import { IonPage, IonContent } from "@ionic/vue"
import { createResource } from "frappe-ui"
import { ref, watch, inject } from "vue"
import FormView from "@/components/FormView.vue"
const dayjs = inject("$dayjs")
const employee = inject("$employee")
const today = dayjs().format("YYYY-MM-DD")
const props = defineProps({
id: {
type: String,
required: false,
},
})
// reactive object to store form data
const leaveApplication = ref({})
// get form fields
const formFields = createResource({
url: "hrms.api.get_doctype_fields",
params: { doctype: "Leave Application" },
transform(data) {
let fields = getFilteredFields(data)
return fields.map((field) => {
if (field.fieldname === "half_day_date") field.hidden = true
if (field.fieldname === "posting_date") field.default = today
return field
})
},
onSuccess(_data) {
leaveApprovalDetails.reload()
leaveTypes.reload()
},
})
formFields.reload()
const leaveApprovalDetails = createResource({
url: "hrms.api.get_leave_approval_details",
params: { employee: employee.data.name },
onSuccess(data) {
setLeaveApprovers(data)
},
})
const leaveTypes = createResource({
url: "hrms.api.get_leave_types",
params: {
employee: employee.data.name,
date: today,
},
onSuccess(data) {
setLeaveTypes(data)
},
})
// form scripts
watch(
() => leaveApplication.value.employee,
(employee_id) => {
if (props.id && employee_id !== employee.data.name) {
// if employee is not the current user, set form as read only
setFormReadOnly()
}
}
)
watch(
() => leaveApplication.value.leave_type,
(leave_type) => setLeaveBalance(leave_type)
)
watch(
() => leaveApplication.value.half_day,
(half_day) => setHalfDayDate(half_day)
)
watch(
() => leaveApplication.value.half_day && leaveApplication.value.half_day_date,
() => setTotalLeaveDays()
)
watch(
() => leaveApplication.value.from_date,
(from_date) => {
if (!leaveApplication.value.to_date) {
leaveApplication.value.to_date = from_date
}
// fetch leave types for the selected date
leaveTypes.fetch({
employee: employee.data.name,
date: from_date,
})
}
)
watch(
() => [leaveApplication.value.from_date, leaveApplication.value.to_date],
([from_date, to_date]) => {
validateDates(from_date, to_date)
setHalfDayDateRange()
setTotalLeaveDays()
}
)
// helper functions
function getFilteredFields(fields) {
// reduce noise from the form view by excluding unnecessary fields
// ex: employee and other details can be fetched from the session user
const excludeFields = [
"naming_series",
"sb_other_details",
"salary_slip",
"letter_head",
]
const employeeFields = [
"employee",
"employee_name",
"department",
"company",
"follow_via_email",
"status",
"posting_date",
]
if (!props.id) excludeFields.push(...employeeFields)
return fields.filter((field) => !excludeFields.includes(field.fieldname))
}
function setFormReadOnly() {
if (leaveApplication.value.leave_approver === employee.data.user_id) return
formFields.data.map((field) => (field.read_only = true))
}
function validateDates(from_date, to_date) {
if (!(from_date && to_date)) return
const error_message =
from_date > to_date ? "To Date cannot be before From Date" : ""
const from_date_field = formFields.data.find(
(field) => field.fieldname === "from_date"
)
from_date_field.error_message = error_message
}
function setTotalLeaveDays() {
if (!areValuesSet()) return
const leaveDays = createResource({
url: "hrms.hr.doctype.leave_application.leave_application.get_number_of_leave_days",
params: {
employee: employee.data.name,
leave_type: leaveApplication.value.leave_type,
from_date: leaveApplication.value.from_date,
to_date: leaveApplication.value.to_date,
half_day: leaveApplication.value.half_day,
half_day_date: leaveApplication.value.half_day_date,
},
onSuccess(data) {
leaveApplication.value.total_leave_days = data
},
})
leaveDays.reload()
setLeaveBalance()
}
function setLeaveBalance() {
if (!areValuesSet()) return
const leaveBalance = createResource({
url: "hrms.hr.doctype.leave_application.leave_application.get_leave_balance_on",
params: {
employee: employee.data.name,
date: leaveApplication.value.from_date,
to_date: leaveApplication.value.to_date,
leave_type: leaveApplication.value.leave_type,
consider_all_leaves_in_the_allocation_period: 1,
},
onSuccess(data) {
leaveApplication.value.leave_balance = data
},
})
leaveBalance.reload()
}
function setHalfDayDate(half_day) {
const half_day_date = formFields.data.find(
(field) => field.fieldname === "half_day_date"
)
half_day_date.hidden = !half_day
half_day_date.reqd = half_day
if (!half_day) return
if (leaveApplication.value.from_date === leaveApplication.value.to_date) {
leaveApplication.value.half_day_date = leaveApplication.value.from_date
} else {
setHalfDayDateRange()
}
}
function setHalfDayDateRange() {
const half_day_date = formFields.data.find(
(field) => field.fieldname === "half_day_date"
)
half_day_date.minDate = leaveApplication.value.from_date
half_day_date.maxDate = leaveApplication.value.to_date
}
function setLeaveApprovers(data) {
const leave_approver = formFields.data?.find(
(field) => field.fieldname === "leave_approver"
)
leave_approver.reqd = data?.is_mandatory
leave_approver.documentList = data?.department_approvers.map((approver) => ({
label: approver.full_name
? `${approver.name} : ${approver.full_name}`
: approver.name,
value: approver.name,
}))
leaveApplication.value.leave_approver = data?.leave_approver
leaveApplication.value.leave_approver_name = data?.leave_approver_name
}
function setLeaveTypes(data) {
const leave_type = formFields.data.find(
(field) => field.fieldname === "leave_type"
)
leave_type.documentList = data?.map((leave_type) => ({
label: leave_type,
value: leave_type,
}))
}
function areValuesSet() {
return (
leaveApplication.value.from_date &&
leaveApplication.value.to_date &&
leaveApplication.value.leave_type
)
}
function validateForm() {
setHalfDayDate(leaveApplication.value.half_day)
leaveApplication.value.employee = employee.data.name
}
</script>
|
2302_79757062/hrms
|
frontend/src/views/leave/Form.vue
|
Vue
|
agpl-3.0
| 6,572
|
<template>
<ion-page>
<ListView
doctype="Leave Application"
pageTitle="Leave History"
:tabButtons="TAB_BUTTONS"
:fields="LEAVE_FIELDS"
:filterConfig="FILTER_CONFIG"
/>
</ion-page>
</template>
<script setup>
import { IonPage } from "@ionic/vue"
import ListView from "@/components/ListView.vue"
const TAB_BUTTONS = ["My Leaves", "Team Leaves"]
const LEAVE_FIELDS = [
"name",
"employee",
"employee_name",
"leave_type",
"from_date",
"to_date",
"total_leave_days",
"status",
]
const STATUS_FILTER_OPTIONS = ["Open", "Approved", "Rejected"]
const FILTER_CONFIG = [
{
fieldname: "status",
fieldtype: "Select",
label: "Status",
options: STATUS_FILTER_OPTIONS,
},
{
fieldname: "leave_type",
fieldtype: "Link",
label: "Leave Type",
options: "Leave Type",
},
{
fieldname: "employee",
fieldtype: "Link",
label: "Employee",
options: "Employee",
},
{
fieldname: "department",
fieldtype: "Link",
label: "Department",
options: "Department",
},
{ fieldname: "from_date", fieldtype: "Date", label: "From Date" },
{ fieldname: "to_date", fieldtype: "Date", label: "To Date" },
]
</script>
|
2302_79757062/hrms
|
frontend/src/views/leave/List.vue
|
Vue
|
agpl-3.0
| 1,143
|
<template>
<BaseLayout pageTitle="Salary Slips">
<template #body>
<div class="flex flex-col items-center my-7 p-4">
<div class="flex flex-col w-full bg-white rounded py-5 px-3.5 gap-5">
<div v-if="lastSalarySlip" class="flex flex-col w-full gap-1.5">
<span class="text-gray-600 text-sm font-medium leading-5">
Year To Date
</span>
<span class="text-gray-800 text-xl font-bold leading-6">
{{
formatCurrency(
lastSalarySlip.year_to_date,
lastSalarySlip.currency
)
}}
</span>
</div>
<Autocomplete
label="Payroll Period"
class="w-full"
placeholder="Select Payroll Period"
v-model="selectedPeriod"
:options="payrollPeriods.data"
/>
</div>
<div class="flex flex-col items-center mt-5 mb-7 w-full">
<div
v-if="documents.data?.length"
class="flex flex-col bg-white rounded mt-5 overflow-auto w-full"
>
<div
class="p-3.5 items-center justify-between border-b cursor-pointer"
v-for="link in documents.data"
:key="link.name"
>
<router-link
:to="{
name: 'SalarySlipDetailView',
params: { id: link.name },
}"
v-slot="{ navigate }"
>
<SalarySlipItem :doc="link" @click="navigate" />
</router-link>
</div>
</div>
<EmptyState message="No salary slips found" v-else />
</div>
</div>
</template>
</BaseLayout>
</template>
<script setup>
import { inject, ref, computed, watch, onMounted, onBeforeUnmount } from "vue"
import { Autocomplete, createListResource } from "frappe-ui"
import BaseLayout from "@/components/BaseLayout.vue"
import EmptyState from "@/components/EmptyState.vue"
import SalarySlipItem from "@/components/SalarySlipItem.vue"
import { formatCurrency } from "@/utils/formatters"
let selectedPeriod = ref({})
let periodsByName = ref({})
const employee = inject("$employee")
const dayjs = inject("$dayjs")
const socket = inject("$socket")
const payrollPeriods = createListResource({
doctype: "Payroll Period",
fields: ["name", "start_date", "end_date"],
filters: {
company: employee.data?.company,
},
orderBy: "start_date desc",
auto: true,
transform(data) {
return data.map((period) => {
periodsByName.value[period.name] = period
return {
label: getPeriodLabel(period),
value: period.name,
}
})
},
onSuccess: (data) => {
selectedPeriod.value = data[0]
},
})
const documents = createListResource({
doctype: "Salary Slip",
fields: [
"name",
"start_date",
"end_date",
"currency",
"gross_pay",
"net_pay",
"year_to_date",
],
filters: {
employee: employee.data?.name,
docstatus: 1,
},
orderBy: "end_date desc",
})
const lastSalarySlip = computed(() => documents.data?.[0])
function getPeriodLabel(period) {
return `${dayjs(period?.start_date).format("MMM YYYY")} - ${dayjs(
period?.end_date
).format("MMM YYYY")}`
}
watch(
() => selectedPeriod.value,
(value) => {
let period = periodsByName.value[value?.value]
documents.filters.start_date = [
"between",
[period?.start_date, period?.end_date],
]
documents.reload()
}
)
onMounted(() => {
socket.on("hrms:update_salary_slips", (data) => {
if (data.employee === employee.data.name) {
documents.reload()
}
})
})
onBeforeUnmount(() => {
socket.off("hrms:update_salary_slips")
})
</script>
|
2302_79757062/hrms
|
frontend/src/views/salary_slip/Dashboard.vue
|
Vue
|
agpl-3.0
| 3,430
|
<template>
<ion-page>
<ion-content :fullscreen="true">
<FormView
v-if="formFields.data"
doctype="Salary Slip"
v-model="salarySlip"
:fields="formFields.data"
:id="props.id"
:tabbedView="true"
:tabs="tabs"
:showFormButton="false"
>
<!-- Child Tables -->
<template #earnings="{ isFormReadOnly }">
<SalaryDetailTable
type="Earnings"
:salarySlip="salarySlip"
:isReadOnly="isFormReadOnly"
/>
</template>
<template #deductions="{ isFormReadOnly }">
<SalaryDetailTable
type="Deductions"
:salarySlip="salarySlip"
:isReadOnly="isFormReadOnly"
/>
</template>
<template #formButton>
<ErrorMessage :message="downloadError" class="mt-2" />
<Button
class="w-full rounded py-5 text-base disabled:bg-gray-700 disabled:text-white"
@click="downloadPDF"
variant="solid"
:loading="loading"
>
Download PDF
</Button>
</template>
</FormView>
</ion-content>
</ion-page>
</template>
<script setup>
import { ref, watch } from "vue"
import { IonPage, IonContent } from "@ionic/vue"
import { createResource, ErrorMessage } from "frappe-ui"
import FormView from "@/components/FormView.vue"
import SalaryDetailTable from "@/components/SalaryDetailTable.vue"
import { getCompanyCurrency } from "@/data/currencies"
const props = defineProps({
id: {
type: String,
required: true,
},
})
const downloadError = ref("")
const loading = ref(false)
// reactive object to store form data
const salarySlip = ref({})
// get form fields
const formFields = createResource({
url: "hrms.api.get_doctype_fields",
params: { doctype: "Salary Slip" },
transform(data) {
return getFilteredFields(data)
},
})
formFields.reload()
const tabs = [
{ name: "Details", lastField: "payment_days" },
{ name: "Earnings & Deductions", lastField: "base_total_deduction" },
{ name: "Net Pay Info", lastField: "base_total_in_words" },
{ name: "Income Tax Breakup", lastField: "total_income_tax" },
{ name: "Bank Details", lastField: "bank_account_no" },
]
watch(
() => salarySlip.value.company,
async (company) => {
if (!company) return
const companyCurrency = await getCompanyCurrency(company)
formFields.data?.map((field) => {
if (field.label?.includes("Company Currency")) {
if (salarySlip.value.currency === companyCurrency) {
// hide base currency fields
field.hidden = true
} else {
// set currency in label
field.label = field.label.replace("Company Currency", companyCurrency)
}
}
})
},
{ immediate: true }
)
function getFilteredFields(fields) {
const hasTimesheets = salarySlip.value?.timesheets?.length
if (hasTimesheets) return fields
const excludeFields = [
"timesheets_section",
"timesheets",
"total_working_hours",
"hour_rate",
"base_hour_rate",
"help_section",
"earning_deduction_sb",
]
return fields.filter((field) => !excludeFields.includes(field.fieldname))
}
function downloadPDF() {
const salarySlipName = salarySlip.value.name
loading.value = true
let headers = { "X-Frappe-Site-Name": window.location.hostname }
if (window.csrf_token) {
headers["X-Frappe-CSRF-Token"] = window.csrf_token
}
fetch("/api/method/hrms.api.download_salary_slip", {
method: "POST",
headers,
body: new URLSearchParams({ name: salarySlipName }),
responseType: "blob",
})
.then((response) => {
if (response.ok) {
return response.blob()
} else {
downloadError.value = "Failed to download PDF"
}
})
.then((blob) => {
if (!blob) return
const blobUrl = window.URL.createObjectURL(blob)
const link = document.createElement("a")
link.href = blobUrl
link.download = `${salarySlipName}.pdf`
link.click()
setTimeout(() => {
window.URL.revokeObjectURL(blobUrl)
}, 3000)
})
.catch((error) => {
downloadError.value = `Failed to download PDF: ${error.message}`
})
.finally(() => {
loading.value = false
})
}
</script>
|
2302_79757062/hrms
|
frontend/src/views/salary_slip/Detail.vue
|
Vue
|
agpl-3.0
| 4,006
|
module.exports = {
presets: [require("frappe-ui/src/utils/tailwind.config")],
content: [
"./index.html",
"./src/**/*.{vue,js,ts,jsx,tsx}",
"./node_modules/frappe-ui/src/components/**/*.{vue,js,ts,jsx,tsx}",
"../node_modules/frappe-ui/src/components/**/*.{vue,js,ts,jsx,tsx}",
],
theme: {
extend: {
screens: {
standalone: {
raw: "(display-mode: standalone)",
},
},
padding: {
"safe-top": "env(safe-area-inset-top)",
"safe-right": "env(safe-area-inset-right)",
"safe-bottom": "env(safe-area-inset-bottom)",
"safe-left": "env(safe-area-inset-left)",
},
},
},
plugins: [],
}
|
2302_79757062/hrms
|
frontend/tailwind.config.js
|
JavaScript
|
agpl-3.0
| 630
|
import { defineConfig } from "vite"
import vue from "@vitejs/plugin-vue"
import { VitePWA } from "vite-plugin-pwa"
import frappeui from "frappe-ui/vite"
import path from "path"
import fs from "fs"
export default defineConfig({
server: {
port: 8080,
proxy: getProxyOptions(),
},
plugins: [
vue(),
frappeui(),
VitePWA({
registerType: "autoUpdate",
strategies: "injectManifest",
injectRegister: null,
devOptions: {
enabled: true,
},
manifest: {
display: "standalone",
name: "Frappe HR",
short_name: "Frappe HR",
start_url: "/hrms",
description: "Everyday HR & Payroll operations at your fingertips",
theme_color: "#ffffff",
icons: [
{
src: "/assets/hrms/manifest/manifest-icon-192.maskable.png",
sizes: "192x192",
type: "image/png",
purpose: "any",
},
{
src: "/assets/hrms/manifest/manifest-icon-192.maskable.png",
sizes: "192x192",
type: "image/png",
purpose: "maskable",
},
{
src: "/assets/hrms/manifest/manifest-icon-512.maskable.png",
sizes: "512x512",
type: "image/png",
purpose: "any",
},
{
src: "/assets/hrms/manifest/manifest-icon-512.maskable.png",
sizes: "512x512",
type: "image/png",
purpose: "maskable",
},
],
},
}),
],
resolve: {
alias: {
"@": path.resolve(__dirname, "src"),
},
},
build: {
outDir: "../hrms/public/frontend",
emptyOutDir: true,
target: "es2015",
commonjsOptions: {
include: [/tailwind.config.js/, /node_modules/],
},
sourcemap: true,
rollupOptions: {
output: {
manualChunks: {
"frappe-ui": ["frappe-ui"],
},
},
},
},
optimizeDeps: {
include: [
"frappe-ui > feather-icons",
"showdown",
"tailwind.config.js",
"engine.io-client",
],
},
})
function getProxyOptions() {
const config = getCommonSiteConfig()
const webserver_port = config ? config.webserver_port : 8000
if (!config) {
console.log("No common_site_config.json found, using default port 8000")
}
return {
"^/(app|login|api|assets|files|private)": {
target: `http://127.0.0.1:${webserver_port}`,
ws: true,
router: function (req) {
const site_name = req.headers.host.split(":")[0]
console.log(`Proxying ${req.url} to ${site_name}:${webserver_port}`)
return `http://${site_name}:${webserver_port}`
},
},
}
}
function getCommonSiteConfig() {
let currentDir = path.resolve(".")
// traverse up till we find frappe-bench with sites directory
while (currentDir !== "/") {
if (
fs.existsSync(path.join(currentDir, "sites")) &&
fs.existsSync(path.join(currentDir, "apps"))
) {
let configPath = path.join(currentDir, "sites", "common_site_config.json")
if (fs.existsSync(configPath)) {
return JSON.parse(fs.readFileSync(configPath))
}
return null
}
currentDir = path.resolve(currentDir, "..")
}
return null
}
|
2302_79757062/hrms
|
frontend/vite.config.js
|
JavaScript
|
agpl-3.0
| 2,933
|
import frappe
__version__ = "16.0.0-dev"
def refetch_resource(cache_key: str | list, user=None):
frappe.publish_realtime(
"hrms:refetch_resource",
{"cache_key": cache_key},
user=user or frappe.session.user,
after_commit=True,
)
|
2302_79757062/hrms
|
hrms/__init__.py
|
Python
|
agpl-3.0
| 241
|
import frappe
from frappe import _
from frappe.model import get_permitted_fields
from frappe.model.workflow import get_workflow_name
from frappe.query_builder import Order
from frappe.utils import getdate, strip_html
SUPPORTED_FIELD_TYPES = [
"Link",
"Select",
"Small Text",
"Text",
"Long Text",
"Text Editor",
"Table",
"Check",
"Data",
"Float",
"Int",
"Section Break",
"Date",
"Time",
"Datetime",
"Currency",
]
@frappe.whitelist()
def get_current_user_info() -> dict:
current_user = frappe.session.user
user = frappe.db.get_value(
"User", current_user, ["name", "first_name", "full_name", "user_image"], as_dict=True
)
user["roles"] = frappe.get_roles(current_user)
return user
@frappe.whitelist()
def get_current_employee_info() -> dict:
current_user = frappe.session.user
employee = frappe.db.get_value(
"Employee",
{"user_id": current_user, "status": "Active"},
[
"name",
"first_name",
"employee_name",
"designation",
"department",
"company",
"reports_to",
"user_id",
],
as_dict=True,
)
return employee
@frappe.whitelist()
def get_all_employees() -> list[dict]:
return frappe.get_all(
"Employee",
fields=[
"name",
"employee_name",
"designation",
"department",
"company",
"reports_to",
"user_id",
"image",
"status",
],
limit=999999,
)
# HR Settings
@frappe.whitelist()
def get_hr_settings() -> dict:
settings = frappe.db.get_singles_dict("HR Settings", cast=True)
return frappe._dict(
allow_employee_checkin_from_mobile_app=settings.allow_employee_checkin_from_mobile_app,
allow_geolocation_tracking=settings.allow_geolocation_tracking,
)
# Notifications
@frappe.whitelist()
def get_unread_notifications_count() -> int:
return frappe.db.count(
"PWA Notification",
{"to_user": frappe.session.user, "read": 0},
)
@frappe.whitelist()
def mark_all_notifications_as_read() -> None:
frappe.db.set_value(
"PWA Notification",
{"to_user": frappe.session.user, "read": 0},
"read",
1,
update_modified=False,
)
@frappe.whitelist()
def are_push_notifications_enabled() -> bool:
try:
return frappe.db.get_single_value("Push Notification Settings", "enable_push_notification_relay")
except frappe.DoesNotExistError:
# push notifications are not supported in the current framework version
return False
# Leaves and Holidays
@frappe.whitelist()
def get_leave_applications(
employee: str,
approver_id: str | None = None,
for_approval: bool = False,
limit: int | None = None,
) -> list[dict]:
filters = get_leave_application_filters(employee, approver_id, for_approval)
fields = [
"name",
"posting_date",
"employee",
"employee_name",
"leave_type",
"status",
"from_date",
"to_date",
"half_day",
"half_day_date",
"description",
"total_leave_days",
"leave_balance",
"leave_approver",
"posting_date",
]
if workflow_state_field := get_workflow_state_field("Leave Application"):
fields.append(workflow_state_field)
applications = frappe.get_list(
"Leave Application",
fields=fields,
filters=filters,
order_by="posting_date desc",
limit=limit,
)
if workflow_state_field:
for application in applications:
application["workflow_state_field"] = workflow_state_field
return applications
def get_leave_application_filters(
employee: str,
approver_id: str | None = None,
for_approval: bool = False,
) -> dict:
filters = frappe._dict()
if for_approval:
filters.docstatus = 0
filters.employee = ("!=", employee)
if workflow := get_workflow("Leave Application"):
allowed_states = get_allowed_states_for_workflow(workflow, approver_id)
filters[workflow.workflow_state_field] = ("in", allowed_states)
else:
filters.status = "Open"
filters.leave_approver = approver_id
else:
filters.docstatus = ("!=", 2)
filters.employee = employee
return filters
@frappe.whitelist()
def get_leave_balance_map(employee: str) -> dict[str, dict[str, float]]:
"""
Returns a map of leave type and balance details like:
{
'Casual Leave': {'allocated_leaves': 10.0, 'balance_leaves': 5.0},
'Earned Leave': {'allocated_leaves': 3.0, 'balance_leaves': 3.0},
}
"""
from hrms.hr.doctype.leave_application.leave_application import get_leave_details
date = getdate()
leave_map = {}
leave_details = get_leave_details(employee, date)
allocation = leave_details["leave_allocation"]
for leave_type, details in allocation.items():
leave_map[leave_type] = {
"allocated_leaves": details.get("total_leaves"),
"balance_leaves": details.get("remaining_leaves"),
}
return leave_map
@frappe.whitelist()
def get_holidays_for_employee(employee: str) -> list[dict]:
from erpnext.setup.doctype.employee.employee import get_holiday_list_for_employee
holiday_list = get_holiday_list_for_employee(employee, raise_exception=False)
if not holiday_list:
return []
Holiday = frappe.qb.DocType("Holiday")
holidays = (
frappe.qb.from_(Holiday)
.select(Holiday.name, Holiday.holiday_date, Holiday.description)
.where((Holiday.parent == holiday_list) & (Holiday.weekly_off == 0))
.orderby(Holiday.holiday_date, order=Order.asc)
).run(as_dict=True)
for holiday in holidays:
holiday["description"] = strip_html(holiday["description"] or "").strip()
return holidays
@frappe.whitelist()
def get_leave_approval_details(employee: str) -> dict:
leave_approver, department = frappe.get_cached_value(
"Employee",
employee,
["leave_approver", "department"],
)
if not leave_approver and department:
leave_approver = frappe.db.get_value(
"Department Approver",
{"parent": department, "parentfield": "leave_approvers", "idx": 1},
"approver",
)
leave_approver_name = frappe.db.get_value("User", leave_approver, "full_name", cache=True)
department_approvers = get_department_approvers(department, "leave_approvers")
if leave_approver and leave_approver not in [approver.name for approver in department_approvers]:
department_approvers.append({"name": leave_approver, "full_name": leave_approver_name})
return dict(
leave_approver=leave_approver,
leave_approver_name=leave_approver_name,
department_approvers=department_approvers,
is_mandatory=frappe.db.get_single_value(
"HR Settings", "leave_approver_mandatory_in_leave_application"
),
)
def get_department_approvers(department: str, parentfield: str) -> list[str]:
if not department:
return []
department_details = frappe.db.get_value("Department", department, ["lft", "rgt"], as_dict=True)
departments = frappe.get_all(
"Department",
filters={
"lft": ("<=", department_details.lft),
"rgt": (">=", department_details.rgt),
"disabled": 0,
},
pluck="name",
)
Approver = frappe.qb.DocType("Department Approver")
User = frappe.qb.DocType("User")
department_approvers = (
frappe.qb.from_(User)
.join(Approver)
.on(Approver.approver == User.name)
.select(User.name.as_("name"), User.full_name.as_("full_name"))
.where((Approver.parent.isin(departments)) & (Approver.parentfield == parentfield))
).run(as_dict=True)
return department_approvers
@frappe.whitelist()
def get_leave_types(employee: str, date: str) -> list:
from hrms.hr.doctype.leave_application.leave_application import get_leave_details
date = date or getdate()
leave_details = get_leave_details(employee, date)
leave_types = list(leave_details["leave_allocation"].keys()) + leave_details["lwps"]
return leave_types
# Expense Claims
@frappe.whitelist()
def get_expense_claims(
employee: str,
approver_id: str | None = None,
for_approval: bool = False,
limit: int | None = None,
) -> list[dict]:
filters = get_expense_claim_filters(employee, approver_id, for_approval)
fields = [
"`tabExpense Claim`.name",
"`tabExpense Claim`.posting_date",
"`tabExpense Claim`.employee",
"`tabExpense Claim`.employee_name",
"`tabExpense Claim`.approval_status",
"`tabExpense Claim`.status",
"`tabExpense Claim`.expense_approver",
"`tabExpense Claim`.total_claimed_amount",
"`tabExpense Claim`.posting_date",
"`tabExpense Claim`.company",
"`tabExpense Claim Detail`.expense_type",
"count(`tabExpense Claim Detail`.expense_type) as total_expenses",
]
if workflow_state_field := get_workflow_state_field("Expense Claim"):
fields.append(workflow_state_field)
claims = frappe.get_list(
"Expense Claim",
fields=fields,
filters=filters,
order_by="`tabExpense Claim`.posting_date desc",
group_by="`tabExpense Claim`.name",
limit=limit,
)
if workflow_state_field:
for claim in claims:
claim["workflow_state_field"] = workflow_state_field
return claims
def get_expense_claim_filters(
employee: str,
approver_id: str | None = None,
for_approval: bool = False,
) -> dict:
filters = frappe._dict()
if for_approval:
filters.docstatus = 0
filters.employee = ("!=", employee)
if workflow := get_workflow("Expense Claim"):
allowed_states = get_allowed_states_for_workflow(workflow, approver_id)
filters[workflow.workflow_state_field] = ("in", allowed_states)
else:
filters.status = "Draft"
filters.expense_approver = approver_id
else:
filters.docstatus = ("!=", 2)
filters.employee = employee
return filters
@frappe.whitelist()
def get_expense_claim_summary(employee: str) -> dict:
from frappe.query_builder.functions import Sum
Claim = frappe.qb.DocType("Expense Claim")
pending_claims_case = (
frappe.qb.terms.Case().when(Claim.approval_status == "Draft", Claim.total_claimed_amount).else_(0)
)
sum_pending_claims = Sum(pending_claims_case).as_("total_pending_amount")
approved_claims_case = (
frappe.qb.terms.Case()
.when(Claim.approval_status == "Approved", Claim.total_sanctioned_amount)
.else_(0)
)
sum_approved_claims = Sum(approved_claims_case).as_("total_approved_amount")
rejected_claims_case = (
frappe.qb.terms.Case()
.when(Claim.approval_status == "Rejected", Claim.total_sanctioned_amount)
.else_(0)
)
sum_rejected_claims = Sum(rejected_claims_case).as_("total_rejected_amount")
summary = (
frappe.qb.from_(Claim)
.select(
sum_pending_claims,
sum_approved_claims,
sum_rejected_claims,
Claim.company,
)
.where((Claim.docstatus != 2) & (Claim.employee == employee))
).run(as_dict=True)[0]
currency = frappe.db.get_value("Company", summary.company, "default_currency")
summary["currency"] = currency
return summary
@frappe.whitelist()
def get_expense_type_description(expense_type: str) -> str:
return frappe.db.get_value("Expense Claim Type", expense_type, "description")
@frappe.whitelist()
def get_expense_claim_types() -> list[dict]:
ClaimType = frappe.qb.DocType("Expense Claim Type")
return (frappe.qb.from_(ClaimType).select(ClaimType.name, ClaimType.description)).run(as_dict=True)
@frappe.whitelist()
def get_expense_approval_details(employee: str) -> dict:
expense_approver, department = frappe.get_cached_value(
"Employee",
employee,
["expense_approver", "department"],
)
if not expense_approver and department:
expense_approver = frappe.db.get_value(
"Department Approver",
{"parent": department, "parentfield": "expense_approvers", "idx": 1},
"approver",
)
expense_approver_name = frappe.db.get_value("User", expense_approver, "full_name", cache=True)
department_approvers = get_department_approvers(department, "expense_approvers")
if expense_approver and expense_approver not in [approver.name for approver in department_approvers]:
department_approvers.append({"name": expense_approver, "full_name": expense_approver_name})
return dict(
expense_approver=expense_approver,
expense_approver_name=expense_approver_name,
department_approvers=department_approvers,
is_mandatory=frappe.db.get_single_value("HR Settings", "expense_approver_mandatory_in_expense_claim"),
)
# Employee Advance
@frappe.whitelist()
def get_employee_advance_balance(employee: str) -> list[dict]:
Advance = frappe.qb.DocType("Employee Advance")
advances = (
frappe.qb.from_(Advance)
.select(
Advance.name,
Advance.employee,
Advance.status,
Advance.purpose,
Advance.paid_amount,
(Advance.paid_amount - (Advance.claimed_amount + Advance.return_amount)).as_("balance_amount"),
Advance.posting_date,
Advance.currency,
)
.where(
(Advance.docstatus == 1)
& (Advance.paid_amount)
& (Advance.employee == employee)
# don't need claimed & returned advances, only partly or completely paid ones
& (Advance.status.isin(["Paid", "Unpaid"]))
)
.orderby(Advance.posting_date, order=Order.desc)
).run(as_dict=True)
return advances
@frappe.whitelist()
def get_advance_account(company: str) -> str | None:
return frappe.db.get_value("Company", company, "default_employee_advance_account", cache=True)
# Company
@frappe.whitelist()
def get_company_currencies() -> dict:
Company = frappe.qb.DocType("Company")
Currency = frappe.qb.DocType("Currency")
query = (
frappe.qb.from_(Company)
.join(Currency)
.on(Company.default_currency == Currency.name)
.select(
Company.name,
Company.default_currency,
Currency.name.as_("currency"),
Currency.symbol.as_("symbol"),
)
)
companies = query.run(as_dict=True)
return {company.name: (company.default_currency, company.symbol) for company in companies}
@frappe.whitelist()
def get_currency_symbols() -> dict:
Currency = frappe.qb.DocType("Currency")
currencies = (frappe.qb.from_(Currency).select(Currency.name, Currency.symbol)).run(as_dict=True)
return {currency.name: currency.symbol or currency.name for currency in currencies}
@frappe.whitelist()
def get_company_cost_center_and_expense_account(company: str) -> dict:
return frappe.db.get_value(
"Company", company, ["cost_center", "default_expense_claim_payable_account"], as_dict=True
)
# Form View APIs
@frappe.whitelist()
def get_doctype_fields(doctype: str) -> list[dict]:
fields = frappe.get_meta(doctype).fields
return [
field
for field in fields
if field.fieldtype in SUPPORTED_FIELD_TYPES and field.fieldname != "amended_from"
]
@frappe.whitelist()
def get_doctype_states(doctype: str) -> dict:
states = frappe.get_meta(doctype).states
return {state.title: state.color.lower() for state in states}
# File
@frappe.whitelist()
def get_attachments(dt: str, dn: str):
from frappe.desk.form.load import get_attachments
return get_attachments(dt, dn)
@frappe.whitelist()
def upload_base64_file(content, filename, dt=None, dn=None, fieldname=None):
import base64
import io
from mimetypes import guess_type
from PIL import Image, ImageOps
from frappe.handler import ALLOWED_MIMETYPES
decoded_content = base64.b64decode(content)
content_type = guess_type(filename)[0]
if content_type not in ALLOWED_MIMETYPES:
frappe.throw(_("You can only upload JPG, PNG, PDF, TXT or Microsoft documents."))
if content_type.startswith("image/jpeg"):
# transpose the image according to the orientation tag, and remove the orientation data
with Image.open(io.BytesIO(decoded_content)) as image:
transpose_img = ImageOps.exif_transpose(image)
# convert the image back to bytes
file_content = io.BytesIO()
transpose_img.save(file_content, format="JPEG")
file_content = file_content.getvalue()
else:
file_content = decoded_content
return frappe.get_doc(
{
"doctype": "File",
"attached_to_doctype": dt,
"attached_to_name": dn,
"attached_to_field": fieldname,
"folder": "Home",
"file_name": filename,
"content": file_content,
"is_private": 1,
}
).insert()
@frappe.whitelist()
def delete_attachment(filename: str):
frappe.delete_doc("File", filename)
@frappe.whitelist()
def download_salary_slip(name: str):
import base64
from frappe.utils.print_format import download_pdf
default_print_format = frappe.get_meta("Salary Slip").default_print_format or "Standard"
try:
download_pdf("Salary Slip", name, format=default_print_format)
except Exception:
frappe.throw(_("Failed to download Salary Slip PDF"))
base64content = base64.b64encode(frappe.local.response.filecontent)
content_type = frappe.local.response.type
return f"data:{content_type};base64," + base64content.decode("utf-8")
# Workflow
@frappe.whitelist()
def get_workflow(doctype: str) -> dict:
workflow = get_workflow_name(doctype)
if not workflow:
return frappe._dict()
return frappe.get_doc("Workflow", workflow)
def get_workflow_state_field(doctype: str) -> str | None:
workflow_name = get_workflow_name(doctype)
if not workflow_name:
return None
override_status, workflow_state_field = frappe.db.get_value(
"Workflow",
workflow_name,
["override_status", "workflow_state_field"],
)
# NOTE: checkbox labelled 'Don't Override Status' is named override_status hence the inverted logic
if not override_status:
return workflow_state_field
return None
def get_allowed_states_for_workflow(workflow: dict, user_id: str) -> list[str]:
user_roles = frappe.get_roles(user_id)
return [transition.state for transition in workflow.transitions if transition.allowed in user_roles]
# Permissions
@frappe.whitelist()
def get_permitted_fields_for_write(doctype: str) -> list[str]:
return get_permitted_fields(doctype, permission_type="write")
|
2302_79757062/hrms
|
hrms/api/__init__.py
|
Python
|
agpl-3.0
| 17,184
|
import frappe
from frappe import _
from frappe.utils import add_days, date_diff
from erpnext.setup.doctype.employee.employee import get_holiday_list_for_employee
from hrms.hr.doctype.shift_assignment.shift_assignment import ShiftAssignment
from hrms.hr.doctype.shift_assignment_tool.shift_assignment_tool import create_shift_assignment
@frappe.whitelist()
def get_values(doctype: str, name: str, fields: list) -> dict[str, str]:
return frappe.db.get_value(doctype, name, fields, as_dict=True)
@frappe.whitelist()
def get_events(
month_start: str, month_end: str, employee_filters: dict[str, str], shift_filters: dict[str, str]
) -> dict[str, list[dict]]:
holidays = get_holidays(month_start, month_end, employee_filters)
leaves = get_leaves(month_start, month_end, employee_filters)
shifts = get_shifts(month_start, month_end, employee_filters, shift_filters)
events = {}
for event in [holidays, leaves, shifts]:
for key, value in event.items():
if key in events:
events[key].extend(value)
else:
events[key] = value
return events
@frappe.whitelist()
def create_shift_assignment_schedule(
employee: str,
company: str,
shift_type: str,
status: str,
start_date: str,
end_date: str | None,
repeat_on_days: list[str],
frequency: str,
) -> None:
schedule = frappe.get_doc(
{
"doctype": "Shift Assignment Schedule",
"frequency": frequency,
"repeat_on_days": [{"day": day} for day in repeat_on_days],
"enabled": 0 if end_date else 1,
"employee": employee,
"company": company,
"shift_type": shift_type,
"shift_status": status,
}
).insert()
if not end_date or date_diff(end_date, start_date) <= 90:
return schedule.create_shifts(start_date, end_date)
frappe.enqueue(schedule.create_shifts, timeout=4500, start_date=start_date, end_date=end_date)
@frappe.whitelist()
def delete_shift_assignment_schedule(schedule: str) -> None:
for shift_assignment in frappe.get_all("Shift Assignment", {"schedule": schedule}, pluck="name"):
doc = frappe.get_doc("Shift Assignment", shift_assignment)
if doc.docstatus == 1:
doc.cancel()
frappe.delete_doc("Shift Assignment", shift_assignment)
frappe.delete_doc("Shift Assignment Schedule", schedule)
@frappe.whitelist()
def swap_shift(
src_shift: str, src_date: str, tgt_employee: str, tgt_date: str, tgt_shift: str | None
) -> None:
if src_shift == tgt_shift:
frappe.throw(_("Source and target shifts cannot be the same"))
if tgt_shift:
tgt_shift_doc = frappe.get_doc("Shift Assignment", tgt_shift)
tgt_company = tgt_shift_doc.company
break_shift(tgt_shift_doc, tgt_date)
else:
tgt_company = frappe.db.get_value("Employee", tgt_employee, "company")
src_shift_doc = frappe.get_doc("Shift Assignment", src_shift)
break_shift(src_shift_doc, src_date)
insert_shift(
tgt_employee, tgt_company, src_shift_doc.shift_type, tgt_date, tgt_date, src_shift_doc.status
)
if tgt_shift:
insert_shift(
src_shift_doc.employee,
src_shift_doc.company,
tgt_shift_doc.shift_type,
src_date,
src_date,
tgt_shift_doc.status,
)
@frappe.whitelist()
def break_shift(assignment: str | ShiftAssignment, date: str) -> None:
if isinstance(assignment, str):
assignment = frappe.get_doc("Shift Assignment", assignment)
if assignment.end_date and date_diff(assignment.end_date, date) < 0:
frappe.throw(_("Cannot break shift after end date"))
if date_diff(assignment.start_date, date) > 0:
frappe.throw(_("Cannot break shift before start date"))
employee = assignment.employee
company = assignment.company
shift_type = assignment.shift_type
status = assignment.status
end_date = assignment.end_date
if date_diff(date, assignment.start_date) == 0:
assignment.cancel()
assignment.delete()
else:
assignment.end_date = add_days(date, -1)
assignment.save()
if not end_date or date_diff(end_date, date) > 0:
create_shift_assignment(employee, company, shift_type, add_days(date, 1), end_date, status)
@frappe.whitelist()
def insert_shift(
employee: str, company: str, shift_type: str, start_date: str, end_date: str | None, status: str
) -> None:
filters = {
"doctype": "Shift Assignment",
"employee": employee,
"company": company,
"shift_type": shift_type,
"status": status,
}
prev_shift = frappe.db.exists(dict({"end_date": add_days(start_date, -1)}, **filters))
next_shift = (
frappe.db.exists(dict({"start_date": add_days(end_date, 1)}, **filters)) if end_date else None
)
if prev_shift:
if next_shift:
end_date = frappe.db.get_value("Shift Assignment", next_shift, "end_date")
frappe.db.set_value("Shift Assignment", next_shift, "docstatus", 2)
frappe.delete_doc("Shift Assignment", next_shift)
frappe.db.set_value("Shift Assignment", prev_shift, "end_date", end_date or None)
elif next_shift:
frappe.db.set_value("Shift Assignment", next_shift, "start_date", start_date)
else:
create_shift_assignment(employee, company, shift_type, start_date, end_date, status)
def get_holidays(month_start: str, month_end: str, employee_filters: dict[str, str]) -> dict[str, list[dict]]:
holidays = {}
for employee in frappe.get_list("Employee", filters=employee_filters, pluck="name"):
if holiday_list := get_holiday_list_for_employee(employee, raise_exception=False):
holidays[employee] = frappe.get_all(
"Holiday",
filters={"parent": holiday_list, "holiday_date": ["between", [month_start, month_end]]},
fields=["name as holiday", "holiday_date", "description", "weekly_off"],
)
return holidays
def get_leaves(month_start: str, month_end: str, employee_filters: dict[str, str]) -> dict[str, list[dict]]:
LeaveApplication = frappe.qb.DocType("Leave Application")
Employee = frappe.qb.DocType("Employee")
query = (
frappe.qb.select(
LeaveApplication.name.as_("leave"),
LeaveApplication.employee,
LeaveApplication.leave_type,
LeaveApplication.from_date,
LeaveApplication.to_date,
)
.from_(LeaveApplication)
.left_join(Employee)
.on(LeaveApplication.employee == Employee.name)
.where(
(LeaveApplication.docstatus == 1)
& (LeaveApplication.status == "Approved")
& (LeaveApplication.from_date <= month_end)
& (LeaveApplication.to_date >= month_start)
)
)
for filter in employee_filters:
query = query.where(Employee[filter] == employee_filters[filter])
return group_by_employee(query.run(as_dict=True))
def get_shifts(
month_start: str, month_end: str, employee_filters: dict[str, str], shift_filters: dict[str, str]
) -> dict[str, list[dict]]:
ShiftAssignment = frappe.qb.DocType("Shift Assignment")
ShiftType = frappe.qb.DocType("Shift Type")
Employee = frappe.qb.DocType("Employee")
query = (
frappe.qb.select(
ShiftAssignment.name,
ShiftAssignment.employee,
ShiftAssignment.shift_type,
ShiftAssignment.start_date,
ShiftAssignment.end_date,
ShiftAssignment.status,
ShiftType.start_time,
ShiftType.end_time,
ShiftType.color,
)
.from_(ShiftAssignment)
.left_join(ShiftType)
.on(ShiftAssignment.shift_type == ShiftType.name)
.left_join(Employee)
.on(ShiftAssignment.employee == Employee.name)
.where(
(ShiftAssignment.docstatus == 1)
& (ShiftAssignment.start_date <= month_end)
& ((ShiftAssignment.end_date >= month_start) | (ShiftAssignment.end_date.isnull()))
)
)
for filter in employee_filters:
query = query.where(Employee[filter] == employee_filters[filter])
for filter in shift_filters:
query = query.where(ShiftAssignment[filter] == shift_filters[filter])
return group_by_employee(query.run(as_dict=True))
def group_by_employee(events: list[dict]) -> dict[str, list[dict]]:
grouped_events = {}
for event in events:
grouped_events.setdefault(event["employee"], []).append(
{k: v for k, v in event.items() if k != "employee"}
)
return grouped_events
|
2302_79757062/hrms
|
hrms/api/roster.py
|
Python
|
agpl-3.0
| 7,805
|
from frappe import _
def get_data():
return [{"module_name": "HRMS", "type": "module", "label": _("HRMS")}]
|
2302_79757062/hrms
|
hrms/config/desktop.py
|
Python
|
agpl-3.0
| 111
|
"""
Configuration for docs
"""
# source_link = "https://github.com/[org_name]/hrms"
# headline = "App that does everything"
# sub_heading = "Yes, you got that right the first time, everything"
def get_context(context):
context.brand_html = "HRMS"
|
2302_79757062/hrms
|
hrms/config/docs.py
|
Python
|
agpl-3.0
| 251
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.desk.form import assign_to
from frappe.model.document import Document
from frappe.utils import add_days, flt, unique
from erpnext.setup.doctype.employee.employee import get_holiday_list_for_employee
from erpnext.setup.doctype.holiday_list.holiday_list import is_holiday
class EmployeeBoardingController(Document):
"""
Create the project and the task for the boarding process
Assign to the concerned person and roles as per the onboarding/separation template
"""
def validate(self):
# remove the task if linked before submitting the form
if self.amended_from:
for activity in self.activities:
activity.task = ""
def on_submit(self):
# create the project for the given employee onboarding
project_name = _(self.doctype) + " : "
if self.doctype == "Employee Onboarding":
project_name += self.job_applicant
else:
project_name += self.employee
project = frappe.get_doc(
{
"doctype": "Project",
"project_name": project_name,
"expected_start_date": self.date_of_joining
if self.doctype == "Employee Onboarding"
else self.resignation_letter_date,
"department": self.department,
"company": self.company,
}
).insert(ignore_permissions=True, ignore_mandatory=True)
self.db_set("project", project.name)
self.db_set("boarding_status", "Pending")
self.reload()
self.create_task_and_notify_user()
def create_task_and_notify_user(self):
# create the task for the given project and assign to the concerned person
holiday_list = self.get_holiday_list()
for activity in self.activities:
if activity.task:
continue
dates = self.get_task_dates(activity, holiday_list)
task = frappe.get_doc(
{
"doctype": "Task",
"project": self.project,
"subject": activity.activity_name + " : " + self.employee_name,
"description": activity.description,
"department": self.department,
"company": self.company,
"task_weight": activity.task_weight,
"exp_start_date": dates[0],
"exp_end_date": dates[1],
}
).insert(ignore_permissions=True)
activity.db_set("task", task.name)
users = [activity.user] if activity.user else []
if activity.role:
user_list = frappe.db.sql_list(
"""
SELECT
DISTINCT(has_role.parent)
FROM
`tabHas Role` has_role
LEFT JOIN `tabUser` user
ON has_role.parent = user.name
WHERE
has_role.parenttype = 'User'
AND user.enabled = 1
AND has_role.role = %s
""",
activity.role,
)
users = unique(users + user_list)
if "Administrator" in users:
users.remove("Administrator")
# assign the task the users
if users:
self.assign_task_to_users(task, users)
def get_holiday_list(self):
if self.doctype == "Employee Separation":
return get_holiday_list_for_employee(self.employee)
else:
if self.employee:
return get_holiday_list_for_employee(self.employee)
else:
if not self.holiday_list:
frappe.throw(_("Please set the Holiday List."), frappe.MandatoryError)
else:
return self.holiday_list
def get_task_dates(self, activity, holiday_list):
start_date = end_date = None
if activity.begin_on is not None:
start_date = add_days(self.boarding_begins_on, activity.begin_on)
start_date = self.update_if_holiday(start_date, holiday_list)
if activity.duration is not None:
end_date = add_days(self.boarding_begins_on, activity.begin_on + activity.duration)
end_date = self.update_if_holiday(end_date, holiday_list)
return [start_date, end_date]
def update_if_holiday(self, date, holiday_list):
while is_holiday(holiday_list, date):
date = add_days(date, 1)
return date
def assign_task_to_users(self, task, users):
for user in users:
args = {
"assign_to": [user],
"doctype": task.doctype,
"name": task.name,
"description": task.description or task.subject,
"notify": self.notify_users_by_email,
}
assign_to.add(args)
def on_cancel(self):
# delete task project
project = self.project
for task in frappe.get_all("Task", filters={"project": project}):
frappe.delete_doc("Task", task.name, force=1)
frappe.delete_doc("Project", project, force=1)
self.db_set("project", "")
for activity in self.activities:
activity.db_set("task", "")
frappe.msgprint(
_("Linked Project {} and Tasks deleted.").format(project), alert=True, indicator="blue"
)
@frappe.whitelist()
def get_onboarding_details(parent, parenttype):
return frappe.get_all(
"Employee Boarding Activity",
fields=[
"activity_name",
"role",
"user",
"required_for_employee_creation",
"description",
"task_weight",
"begin_on",
"duration",
],
filters={"parent": parent, "parenttype": parenttype},
order_by="idx",
)
def update_employee_boarding_status(project, event=None):
employee_onboarding = frappe.db.exists("Employee Onboarding", {"project": project.name})
employee_separation = frappe.db.exists("Employee Separation", {"project": project.name})
if not (employee_onboarding or employee_separation):
return
status = "Pending"
if flt(project.percent_complete) > 0.0 and flt(project.percent_complete) < 100.0:
status = "In Process"
elif flt(project.percent_complete) == 100.0:
status = "Completed"
if employee_onboarding:
frappe.db.set_value("Employee Onboarding", employee_onboarding, "boarding_status", status)
elif employee_separation:
frappe.db.set_value("Employee Separation", employee_separation, "boarding_status", status)
def update_task(task, event=None):
if task.project and not task.flags.from_project:
update_employee_boarding_status(frappe.get_cached_doc("Project", task.project))
|
2302_79757062/hrms
|
hrms/controllers/employee_boarding_controller.py
|
Python
|
agpl-3.0
| 5,862
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.utils import add_days, add_months, comma_sep, getdate, today
from erpnext.setup.doctype.employee.employee import get_all_employee_emails, get_employee_email
from hrms.hr.utils import get_holidays_for_employee
# -----------------
# HOLIDAY REMINDERS
# -----------------
def send_reminders_in_advance_weekly():
to_send_in_advance = int(frappe.db.get_single_value("HR Settings", "send_holiday_reminders"))
frequency = frappe.db.get_single_value("HR Settings", "frequency")
if not (to_send_in_advance and frequency == "Weekly"):
return
send_advance_holiday_reminders("Weekly")
def send_reminders_in_advance_monthly():
to_send_in_advance = int(frappe.db.get_single_value("HR Settings", "send_holiday_reminders"))
frequency = frappe.db.get_single_value("HR Settings", "frequency")
if not (to_send_in_advance and frequency == "Monthly"):
return
send_advance_holiday_reminders("Monthly")
def send_advance_holiday_reminders(frequency):
"""Send Holiday Reminders in Advance to Employees
`frequency` (str): 'Weekly' or 'Monthly'
"""
if frequency == "Weekly":
start_date = getdate()
end_date = add_days(getdate(), 7)
elif frequency == "Monthly":
# Sent on 1st of every month
start_date = getdate()
end_date = add_months(getdate(), 1)
else:
return
employees = frappe.db.get_all("Employee", filters={"status": "Active"}, pluck="name")
for employee in employees:
holidays = get_holidays_for_employee(
employee, start_date, end_date, only_non_weekly=True, raise_exception=False
)
send_holidays_reminder_in_advance(employee, holidays)
def send_holidays_reminder_in_advance(employee, holidays):
if not holidays:
return
employee_doc = frappe.get_doc("Employee", employee)
employee_email = get_employee_email(employee_doc)
frequency = frappe.db.get_single_value("HR Settings", "frequency")
sender_email = get_sender_email()
email_header = _("Holidays this Month.") if frequency == "Monthly" else _("Holidays this Week.")
frappe.sendmail(
sender=sender_email,
recipients=[employee_email],
subject=_("Upcoming Holidays Reminder"),
template="holiday_reminder",
args=dict(
reminder_text=_("Hey {}! This email is to remind you about the upcoming holidays.").format(
employee_doc.get("first_name")
),
message=_("Below is the list of upcoming holidays for you:"),
advance_holiday_reminder=True,
holidays=holidays,
frequency=frequency[:-2],
),
header=email_header,
)
# ------------------
# BIRTHDAY REMINDERS
# ------------------
def send_birthday_reminders():
"""Send Employee birthday reminders if no 'Stop Birthday Reminders' is not set."""
to_send = int(frappe.db.get_single_value("HR Settings", "send_birthday_reminders"))
if not to_send:
return
sender = get_sender_email()
employees_born_today = get_employees_who_are_born_today()
for company, birthday_persons in employees_born_today.items():
employee_emails = get_all_employee_emails(company)
birthday_person_emails = [get_employee_email(doc) for doc in birthday_persons]
recipients = list(set(employee_emails) - set(birthday_person_emails))
reminder_text, message = get_birthday_reminder_text_and_message(birthday_persons)
send_birthday_reminder(recipients, reminder_text, birthday_persons, message, sender)
if len(birthday_persons) > 1:
# special email for people sharing birthdays
for person in birthday_persons:
person_email = person["user_id"] or person["personal_email"] or person["company_email"]
others = [d for d in birthday_persons if d != person]
reminder_text, message = get_birthday_reminder_text_and_message(others)
send_birthday_reminder(person_email, reminder_text, others, message, sender)
def get_birthday_reminder_text_and_message(birthday_persons):
if len(birthday_persons) == 1:
birthday_person_text = birthday_persons[0]["name"]
else:
# converts ["Jim", "Rim", "Dim"] to Jim, Rim & Dim
person_names = [d["name"] for d in birthday_persons]
birthday_person_text = comma_sep(person_names, frappe._("{0} & {1}"), False)
reminder_text = _("Today is {0}'s birthday 🎉").format(birthday_person_text)
message = _("A friendly reminder of an important date for our team.")
message += "<br>"
message += _("Everyone, let’s congratulate {0} on their birthday.").format(birthday_person_text)
return reminder_text, message
def send_birthday_reminder(recipients, reminder_text, birthday_persons, message, sender=None):
frappe.sendmail(
sender=sender,
recipients=recipients,
subject=_("Birthday Reminder"),
template="birthday_reminder",
args=dict(
reminder_text=reminder_text,
birthday_persons=birthday_persons,
message=message,
),
header=_("Birthday Reminder 🎂"),
)
def get_employees_who_are_born_today():
"""Get all employee born today & group them based on their company"""
return get_employees_having_an_event_today("birthday")
def get_employees_having_an_event_today(event_type):
"""Get all employee who have `event_type` today
& group them based on their company. `event_type`
can be `birthday` or `work_anniversary`"""
from collections import defaultdict
# Set column based on event type
if event_type == "birthday":
condition_column = "date_of_birth"
elif event_type == "work_anniversary":
condition_column = "date_of_joining"
else:
return
employees_born_today = frappe.db.multisql(
{
"mariadb": f"""
SELECT `personal_email`, `company`, `company_email`, `user_id`, `employee_name` AS 'name', `image`, `date_of_joining`
FROM `tabEmployee`
WHERE
DAY({condition_column}) = DAY(%(today)s)
AND
MONTH({condition_column}) = MONTH(%(today)s)
AND
YEAR({condition_column}) < YEAR(%(today)s)
AND
`status` = 'Active'
""",
"postgres": f"""
SELECT "personal_email", "company", "company_email", "user_id", "employee_name" AS 'name', "image"
FROM "tabEmployee"
WHERE
DATE_PART('day', {condition_column}) = date_part('day', %(today)s)
AND
DATE_PART('month', {condition_column}) = date_part('month', %(today)s)
AND
DATE_PART('year', {condition_column}) < date_part('year', %(today)s)
AND
"status" = 'Active'
""",
},
dict(today=today(), condition_column=condition_column),
as_dict=1,
)
grouped_employees = defaultdict(lambda: [])
for employee_doc in employees_born_today:
grouped_employees[employee_doc.get("company")].append(employee_doc)
return grouped_employees
# --------------------------
# WORK ANNIVERSARY REMINDERS
# --------------------------
def send_work_anniversary_reminders():
"""Send Employee Work Anniversary Reminders if 'Send Work Anniversary Reminders' is checked"""
to_send = int(frappe.db.get_single_value("HR Settings", "send_work_anniversary_reminders"))
if not to_send:
return
sender = get_sender_email()
employees_joined_today = get_employees_having_an_event_today("work_anniversary")
message = _("A friendly reminder of an important date for our team.")
message += "<br>"
message += _("Everyone, let’s congratulate them on their work anniversary!")
for company, anniversary_persons in employees_joined_today.items():
employee_emails = get_all_employee_emails(company)
anniversary_person_emails = [get_employee_email(doc) for doc in anniversary_persons]
recipients = list(set(employee_emails) - set(anniversary_person_emails))
reminder_text = get_work_anniversary_reminder_text(anniversary_persons)
send_work_anniversary_reminder(recipients, reminder_text, anniversary_persons, message, sender)
if len(anniversary_persons) > 1:
# email for people sharing work anniversaries
for person in anniversary_persons:
person_email = person["user_id"] or person["personal_email"] or person["company_email"]
others = [d for d in anniversary_persons if d != person]
reminder_text = get_work_anniversary_reminder_text(others)
send_work_anniversary_reminder(person_email, reminder_text, others, message, sender)
def get_work_anniversary_reminder_text(anniversary_persons: list) -> str:
if len(anniversary_persons) == 1:
anniversary_person = anniversary_persons[0]["name"]
completed_years = getdate().year - anniversary_persons[0]["date_of_joining"].year
return _("Today {0} completed {1} year(s) at our Company! 🎉").format(
_(anniversary_person), completed_years
)
names_grouped_by_years = {}
for person in anniversary_persons:
# Number of years completed at the company
completed_years = getdate().year - person["date_of_joining"].year
names_grouped_by_years.setdefault(completed_years, []).append(person["name"])
person_names_with_years = [
_("{0} completed {1} year(s)").format(comma_sep(person_names, _("{0} & {1}"), False), years)
for years, person_names in names_grouped_by_years.items()
]
# converts ["Jim", "Rim", "Dim"] to Jim, Rim & Dim
anniversary_person = comma_sep(person_names_with_years, _("{0} & {1}"), False)
return _("Today {0} at our Company! 🎉").format(_(anniversary_person))
def send_work_anniversary_reminder(
recipients,
reminder_text,
anniversary_persons,
message,
sender=None,
):
frappe.sendmail(
sender=sender,
recipients=recipients,
subject=_("Work Anniversary Reminder"),
template="anniversary_reminder",
args=dict(
reminder_text=reminder_text,
anniversary_persons=anniversary_persons,
message=message,
),
header=_("Work Anniversary Reminder"),
)
def get_sender_email() -> str | None:
return frappe.db.get_single_value("HR Settings", "sender_email")
|
2302_79757062/hrms
|
hrms/controllers/employee_reminders.py
|
Python
|
agpl-3.0
| 9,641
|
app_name = "hrms"
app_title = "Frappe HR"
app_publisher = "Frappe Technologies Pvt. Ltd."
app_description = "Modern HR and Payroll Software"
app_email = "contact@frappe.io"
app_license = "GNU General Public License (v3)"
required_apps = ["frappe/erpnext"]
source_link = "http://github.com/frappe/hrms"
app_logo_url = "/assets/hrms/images/frappe-hr-logo.svg"
app_home = "/app/hr"
add_to_apps_screen = [
{
"name": "hrms",
"logo": "/assets/hrms/images/frappe-hr-logo.svg",
"title": "Frappe HR",
"route": "/app/hr",
"has_permission": "hrms.hr.utils.check_app_permission",
}
]
# Includes in <head>
# ------------------
# include js, css files in header of desk.html
# app_include_css = "/assets/hrms/css/hrms.css"
app_include_js = [
"hrms.bundle.js",
]
app_include_css = "hrms.bundle.css"
# website
# include js, css files in header of web template
# web_include_css = "/assets/hrms/css/hrms.css"
# web_include_js = "/assets/hrms/js/hrms.js"
# include custom scss in every website theme (without file extension ".scss")
# website_theme_scss = "hrms/public/scss/website"
# include js, css files in header of web form
# webform_include_js = {"doctype": "public/js/doctype.js"}
# webform_include_css = {"doctype": "public/css/doctype.css"}
# include js in page
# page_js = {"page" : "public/js/file.js"}
# include js in doctype views
doctype_js = {
"Employee": "public/js/erpnext/employee.js",
"Company": "public/js/erpnext/company.js",
"Department": "public/js/erpnext/department.js",
"Timesheet": "public/js/erpnext/timesheet.js",
"Payment Entry": "public/js/erpnext/payment_entry.js",
"Journal Entry": "public/js/erpnext/journal_entry.js",
"Delivery Trip": "public/js/erpnext/delivery_trip.js",
"Bank Transaction": "public/js/erpnext/bank_transaction.js",
}
# doctype_list_js = {"doctype" : "public/js/doctype_list.js"}
# doctype_tree_js = {"doctype" : "public/js/doctype_tree.js"}
# doctype_calendar_js = {"doctype" : "public/js/doctype_calendar.js"}
# Home Pages
# ----------
# application home page (will override Website Settings)
# home_page = "login"
# website user home page (by Role)
# role_home_page = {
# "Role": "home_page"
# }
calendars = ["Leave Application"]
# Generators
# ----------
# automatically create page for each record of this doctype
website_generators = ["Job Opening"]
website_route_rules = [
{"from_route": "/hrms/<path:app_path>", "to_route": "hrms"},
{"from_route": "/hr/<path:app_path>", "to_route": "roster"},
]
# Jinja
# ----------
# add methods and filters to jinja environment
jinja = {
"methods": [
"hrms.utils.get_country",
],
}
# Installation
# ------------
# before_install = "hrms.install.before_install"
after_install = "hrms.install.after_install"
after_migrate = "hrms.setup.update_select_perm_after_install"
setup_wizard_complete = "hrms.subscription_utils.update_erpnext_access"
# Uninstallation
# ------------
before_uninstall = "hrms.uninstall.before_uninstall"
# after_uninstall = "hrms.uninstall.after_uninstall"
# Integration Setup
# ------------------
# To set up dependencies/integrations with other apps
# Name of the app being installed is passed as an argument
# before_app_install = "hrms.utils.before_app_install"
after_app_install = "hrms.setup.after_app_install"
# Integration Cleanup
# -------------------
# To clean up dependencies/integrations with other apps
# Name of the app being uninstalled is passed as an argument
before_app_uninstall = "hrms.setup.before_app_uninstall"
# after_app_uninstall = "hrms.utils.after_app_uninstall"
# Desk Notifications
# ------------------
# See frappe.core.notifications.get_notification_config
# notification_config = "hrms.notifications.get_notification_config"
# Permissions
# -----------
# Permissions evaluated in scripted ways
# permission_query_conditions = {
# "Event": "frappe.desk.doctype.event.event.get_permission_query_conditions",
# }
#
# has_permission = {
# "Event": "frappe.desk.doctype.event.event.has_permission",
# }
has_upload_permission = {"Employee": "erpnext.setup.doctype.employee.employee.has_upload_permission"}
# DocType Class
# ---------------
# Override standard doctype classes
override_doctype_class = {
"Employee": "hrms.overrides.employee_master.EmployeeMaster",
"Timesheet": "hrms.overrides.employee_timesheet.EmployeeTimesheet",
"Payment Entry": "hrms.overrides.employee_payment_entry.EmployeePaymentEntry",
"Project": "hrms.overrides.employee_project.EmployeeProject",
}
# Document Events
# ---------------
# Hook on document methods and events
doc_events = {
"User": {
"validate": "erpnext.setup.doctype.employee.employee.validate_employee_role",
"on_update": "erpnext.setup.doctype.employee.employee.update_user_permissions",
},
"Company": {
"validate": "hrms.overrides.company.validate_default_accounts",
"on_update": [
"hrms.overrides.company.make_company_fixtures",
"hrms.overrides.company.set_default_hr_accounts",
],
},
"Holiday List": {
"on_update": "hrms.utils.holiday_list.invalidate_cache",
"on_trash": "hrms.utils.holiday_list.invalidate_cache",
},
"Timesheet": {"validate": "hrms.hr.utils.validate_active_employee"},
"Payment Entry": {
"on_submit": "hrms.hr.doctype.expense_claim.expense_claim.update_payment_for_expense_claim",
"on_cancel": "hrms.hr.doctype.expense_claim.expense_claim.update_payment_for_expense_claim",
"on_update_after_submit": "hrms.hr.doctype.expense_claim.expense_claim.update_payment_for_expense_claim",
},
"Journal Entry": {
"validate": "hrms.hr.doctype.expense_claim.expense_claim.validate_expense_claim_in_jv",
"on_submit": [
"hrms.hr.doctype.expense_claim.expense_claim.update_payment_for_expense_claim",
"hrms.hr.doctype.full_and_final_statement.full_and_final_statement.update_full_and_final_statement_status",
"hrms.payroll.doctype.salary_withholding.salary_withholding.update_salary_withholding_payment_status",
],
"on_update_after_submit": "hrms.hr.doctype.expense_claim.expense_claim.update_payment_for_expense_claim",
"on_cancel": [
"hrms.hr.doctype.expense_claim.expense_claim.update_payment_for_expense_claim",
"hrms.payroll.doctype.salary_slip.salary_slip.unlink_ref_doc_from_salary_slip",
"hrms.hr.doctype.full_and_final_statement.full_and_final_statement.update_full_and_final_statement_status",
"hrms.payroll.doctype.salary_withholding.salary_withholding.update_salary_withholding_payment_status",
],
},
"Loan": {"validate": "hrms.hr.utils.validate_loan_repay_from_salary"},
"Employee": {
"validate": "hrms.overrides.employee_master.validate_onboarding_process",
"on_update": [
"hrms.overrides.employee_master.update_approver_role",
"hrms.overrides.employee_master.publish_update",
],
"after_insert": "hrms.overrides.employee_master.update_job_applicant_and_offer",
"on_trash": "hrms.overrides.employee_master.update_employee_transfer",
"after_delete": "hrms.overrides.employee_master.publish_update",
},
"Project": {"validate": "hrms.controllers.employee_boarding_controller.update_employee_boarding_status"},
"Task": {"on_update": "hrms.controllers.employee_boarding_controller.update_task"},
}
# Scheduled Tasks
# ---------------
scheduler_events = {
"all": [
"hrms.hr.doctype.interview.interview.send_interview_reminder",
],
"hourly": [
"hrms.hr.doctype.daily_work_summary_group.daily_work_summary_group.trigger_emails",
],
"hourly_long": [
"hrms.hr.doctype.shift_type.shift_type.process_auto_attendance_for_all_shifts",
"hrms.hr.doctype.shift_assignment_schedule.shift_assignment_schedule.process_auto_shift_creation",
],
"daily": [
"hrms.controllers.employee_reminders.send_birthday_reminders",
"hrms.controllers.employee_reminders.send_work_anniversary_reminders",
"hrms.hr.doctype.daily_work_summary_group.daily_work_summary_group.send_summary",
"hrms.hr.doctype.interview.interview.send_daily_feedback_reminder",
"hrms.hr.doctype.job_opening.job_opening.close_expired_job_openings",
],
"daily_long": [
"hrms.hr.doctype.leave_ledger_entry.leave_ledger_entry.process_expired_allocation",
"hrms.hr.utils.generate_leave_encashment",
"hrms.hr.utils.allocate_earned_leaves",
],
"weekly": ["hrms.controllers.employee_reminders.send_reminders_in_advance_weekly"],
"monthly": ["hrms.controllers.employee_reminders.send_reminders_in_advance_monthly"],
}
advance_payment_payable_doctypes = ["Gratuity", "Employee Advance"]
invoice_doctypes = ["Expense Claim"]
period_closing_doctypes = ["Payroll Entry"]
accounting_dimension_doctypes = [
"Expense Claim",
"Expense Claim Detail",
"Expense Taxes and Charges",
"Payroll Entry",
]
bank_reconciliation_doctypes = ["Expense Claim"]
# Testing
# -------
before_tests = "hrms.tests.test_utils.before_tests"
# Overriding Methods
# -----------------------------
# get matching queries for Bank Reconciliation
get_matching_queries = "hrms.hr.utils.get_matching_queries"
regional_overrides = {
"India": {
"hrms.hr.utils.calculate_annual_eligible_hra_exemption": "hrms.regional.india.utils.calculate_annual_eligible_hra_exemption",
"hrms.hr.utils.calculate_hra_exemption_for_period": "hrms.regional.india.utils.calculate_hra_exemption_for_period",
},
}
# ERPNext doctypes for Global Search
global_search_doctypes = {
"Default": [
{"doctype": "Salary Slip", "index": 19},
{"doctype": "Leave Application", "index": 20},
{"doctype": "Expense Claim", "index": 21},
{"doctype": "Employee Grade", "index": 37},
{"doctype": "Job Opening", "index": 39},
{"doctype": "Job Applicant", "index": 40},
{"doctype": "Job Offer", "index": 41},
{"doctype": "Salary Structure Assignment", "index": 42},
{"doctype": "Appraisal", "index": 43},
],
}
# override_whitelisted_methods = {
# "frappe.desk.doctype.event.event.get_events": "hrms.event.get_events"
# }
#
# each overriding function accepts a `data` argument;
# generated from the base implementation of the doctype dashboard,
# along with any modifications made in other Frappe apps
override_doctype_dashboards = {
"Employee": "hrms.overrides.dashboard_overrides.get_dashboard_for_employee",
"Holiday List": "hrms.overrides.dashboard_overrides.get_dashboard_for_holiday_list",
"Task": "hrms.overrides.dashboard_overrides.get_dashboard_for_project",
"Project": "hrms.overrides.dashboard_overrides.get_dashboard_for_project",
"Timesheet": "hrms.overrides.dashboard_overrides.get_dashboard_for_timesheet",
}
# exempt linked doctypes from being automatically cancelled
#
# auto_cancel_exempted_doctypes = ["Auto Repeat"]
# User Data Protection
# --------------------
# user_data_fields = [
# {
# "doctype": "{doctype_1}",
# "filter_by": "{filter_by}",
# "redact_fields": ["{field_1}", "{field_2}"],
# "partial": 1,
# },
# {
# "doctype": "{doctype_2}",
# "filter_by": "{filter_by}",
# "partial": 1,
# },
# {
# "doctype": "{doctype_3}",
# "strict": False,
# },
# {
# "doctype": "{doctype_4}"
# }
# ]
# Authentication and authorization
# --------------------------------
# auth_hooks = [
# "hrms.auth.validate"
# ]
# Translation
# --------------------------------
# Make link fields search translated document names for these DocTypes
# Recommended only for DocTypes which have limited documents with untranslated names
# For example: Role, Gender, etc.
# translated_search_doctypes = []
|
2302_79757062/hrms
|
hrms/hooks.py
|
Python
|
agpl-3.0
| 11,323
|
frappe.provide("frappe.dashboards.chart_sources");
frappe.dashboards.chart_sources["Employees by Age"] = {
method: "hrms.hr.dashboard_chart_source.employees_by_age.employees_by_age.get_data",
filters: [
{
fieldname: "company",
label: __("Company"),
fieldtype: "Link",
options: "Company",
default: frappe.defaults.get_user_default("Company"),
},
],
};
|
2302_79757062/hrms
|
hrms/hr/dashboard_chart_source/employees_by_age/employees_by_age.js
|
JavaScript
|
agpl-3.0
| 374
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from dateutil.relativedelta import relativedelta
import frappe
from frappe import _
from frappe.utils import getdate
from frappe.utils.dashboard import cache_source
@frappe.whitelist()
@cache_source
def get_data(
chart_name=None,
chart=None,
no_cache=None,
filters=None,
from_date=None,
to_date=None,
timespan=None,
time_interval=None,
heatmap_year=None,
) -> dict[str, list]:
if filters:
filters = frappe.parse_json(filters)
employees = frappe.db.get_list(
"Employee",
filters={"company": filters.get("company"), "status": "Active"},
pluck="date_of_birth",
)
age_list = get_age_list(employees)
ranges = get_ranges()
age_range, values = get_employees_by_age(age_list, ranges)
return {
"labels": age_range,
"datasets": [
{"name": _("Employees"), "values": values},
],
}
def get_ranges() -> list[tuple[int, int]]:
ranges = []
for i in range(15, 80, 5):
ranges.append((i, i + 4))
ranges.append(80)
return ranges
def get_age_list(employees) -> list[int]:
age_list = []
for dob in employees:
if not dob:
continue
age = relativedelta(getdate(), getdate(dob)).years
age_list.append(age)
return age_list
def get_employees_by_age(age_list, ranges) -> tuple[list[str], list[int]]:
age_range = []
values = []
for bracket in ranges:
if isinstance(bracket, int):
age_range.append(f"{bracket}+")
else:
age_range.append(f"{bracket[0]}-{bracket[1]}")
count = 0
for age in age_list:
if (isinstance(bracket, int) and age >= bracket) or (
isinstance(bracket, tuple) and bracket[0] <= age <= bracket[1]
):
count += 1
values.append(count)
return age_range, values
|
2302_79757062/hrms
|
hrms/hr/dashboard_chart_source/employees_by_age/employees_by_age.py
|
Python
|
agpl-3.0
| 1,777
|
frappe.provide("frappe.dashboards.chart_sources");
frappe.dashboards.chart_sources["Hiring vs Attrition Count"] = {
method: "hrms.hr.dashboard_chart_source.hiring_vs_attrition_count.hiring_vs_attrition_count.get_data",
filters: [
{
fieldname: "company",
label: __("Company"),
fieldtype: "Link",
options: "Company",
default: frappe.defaults.get_user_default("Company"),
},
{
fieldname: "from_date",
label: __("From Date"),
fieldtype: "Date",
default: frappe.defaults.get_user_default("year_start_date"),
reqd: 1,
},
{
fieldname: "to_date",
label: __("To Date"),
fieldtype: "Date",
default: frappe.defaults.get_user_default("year_end_date"),
},
{
fieldname: "time_interval",
label: __("Time Interval"),
fieldtype: "Select",
options: ["Monthly", "Quarterly", "Yearly"],
default: "Monthly",
reqd: 1,
},
],
};
|
2302_79757062/hrms
|
hrms/hr/dashboard_chart_source/hiring_vs_attrition_count/hiring_vs_attrition_count.js
|
JavaScript
|
agpl-3.0
| 885
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.desk.doctype.dashboard_chart.dashboard_chart import get_result
from frappe.utils import getdate
from frappe.utils.dashboard import cache_source
from frappe.utils.dateutils import get_period
@frappe.whitelist()
@cache_source
def get_data(
chart_name=None,
chart=None,
no_cache=None,
filters=None,
from_date=None,
to_date=None,
timespan=None,
time_interval=None,
heatmap_year=None,
) -> dict[str, list]:
if filters:
filters = frappe.parse_json(filters)
from_date = filters.get("from_date")
to_date = filters.get("to_date")
if not to_date:
to_date = getdate()
hiring = get_records(from_date, to_date, "date_of_joining", filters.get("company"))
attrition = get_records(from_date, to_date, "relieving_date", filters.get("company"))
hiring_data = get_result(hiring, filters.get("time_interval"), from_date, to_date, "Count")
attrition_data = get_result(attrition, filters.get("time_interval"), from_date, to_date, "Count")
return {
"labels": [get_period(r[0], filters.get("time_interval")) for r in hiring_data],
"datasets": [
{"name": _("Hiring Count"), "values": [r[1] for r in hiring_data]},
{"name": _("Attrition Count"), "values": [r[1] for r in attrition_data]},
],
}
def get_records(from_date: str, to_date: str, datefield: str, company: str) -> tuple[tuple[str, float, int]]:
filters = [
["Employee", "company", "=", company],
["Employee", datefield, ">=", from_date, False],
["Employee", datefield, "<=", to_date, False],
]
data = frappe.db.get_list(
"Employee",
fields=[f"{datefield} as _unit", "SUM(1)", "COUNT(*)"],
filters=filters,
group_by="_unit",
order_by="_unit asc",
as_list=True,
ignore_ifnull=True,
)
return data
|
2302_79757062/hrms
|
hrms/hr/dashboard_chart_source/hiring_vs_attrition_count/hiring_vs_attrition_count.py
|
Python
|
agpl-3.0
| 1,874
|
// Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Appointment Letter", {
appointment_letter_template: function (frm) {
if (frm.doc.appointment_letter_template) {
frappe.call({
method: "hrms.hr.doctype.appointment_letter.appointment_letter.get_appointment_letter_details",
args: {
template: frm.doc.appointment_letter_template,
},
callback: function (r) {
if (r.message) {
let message_body = r.message;
frm.set_value("introduction", message_body[0].introduction);
frm.set_value("closing_notes", message_body[0].closing_notes);
frm.doc.terms = [];
for (var i in message_body[1].description) {
frm.add_child("terms");
frm.fields_dict.terms.get_value()[i].title =
message_body[1].description[i].title;
frm.fields_dict.terms.get_value()[i].description =
message_body[1].description[i].description;
}
frm.refresh();
}
},
});
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/appointment_letter/appointment_letter.js
|
JavaScript
|
agpl-3.0
| 1,045
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe.model.document import Document
class AppointmentLetter(Document):
pass
@frappe.whitelist()
def get_appointment_letter_details(template):
body = []
intro = frappe.get_list(
"Appointment Letter Template",
fields=["introduction", "closing_notes"],
filters={"name": template},
)[0]
content = frappe.get_all(
"Appointment Letter content",
fields=["title", "description"],
filters={"parent": template},
order_by="idx",
)
body.append(intro)
body.append({"description": content})
return body
|
2302_79757062/hrms
|
hrms/hr/doctype/appointment_letter/appointment_letter.py
|
Python
|
agpl-3.0
| 658
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class AppointmentLettercontent(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/appointment_letter_content/appointment_letter_content.py
|
Python
|
agpl-3.0
| 230
|
// Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Appointment Letter Template", {
// refresh: function(frm) {
// }
});
|
2302_79757062/hrms
|
hrms/hr/doctype/appointment_letter_template/appointment_letter_template.js
|
JavaScript
|
agpl-3.0
| 212
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class AppointmentLetterTemplate(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/appointment_letter_template/appointment_letter_template.py
|
Python
|
agpl-3.0
| 231
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
frappe.ui.form.on("Appraisal", {
refresh(frm) {
if (!frm.doc.__islocal) {
frm.trigger("add_custom_buttons");
frm.trigger("show_feedback_history");
frm.trigger("setup_chart");
}
// don't allow removing image (fetched from employee)
frm.sidebar.image_wrapper.find(".sidebar-image-actions").addClass("hide");
},
appraisal_template(frm) {
if (frm.doc.appraisal_template) {
frm.call("set_kras_and_rating_criteria", () => {
frm.refresh_field("appraisal_kra");
frm.refresh_field("feedback_ratings");
});
}
},
appraisal_cycle(frm) {
if (frm.doc.appraisal_cycle) {
frappe.run_serially([
() => {
if (frm.doc.__islocal && frm.doc.appraisal_cycle) {
frappe.db.get_value(
"Appraisal Cycle",
frm.doc.appraisal_cycle,
"kra_evaluation_method",
(r) => {
if (r.kra_evaluation_method) {
frm.set_value(
"rate_goals_manually",
cint(r.kra_evaluation_method === "Manual Rating"),
);
}
},
);
}
},
() => {
frm.call({
method: "set_appraisal_template",
doc: frm.doc,
});
},
]);
}
},
add_custom_buttons(frm) {
frm.add_custom_button(__("View Goals"), function () {
frappe.route_options = {
company: frm.doc.company,
employee: frm.doc.employee,
appraisal_cycle: frm.doc.appraisal_cycle,
};
frappe.set_route("Tree", "Goal");
});
},
show_feedback_history(frm) {
frappe.require("performance.bundle.js", () => {
const feedback_history = new hrms.PerformanceFeedback({
frm: frm,
wrapper: $(frm.fields_dict.feedback_html.wrapper),
});
feedback_history.refresh();
});
},
setup_chart(frm) {
const labels = [];
const maximum_scores = [];
const scores = [];
frm.doc.appraisal_kra.forEach((d) => {
labels.push(d.kra);
maximum_scores.push(d.per_weightage || 0);
scores.push(d.goal_score || 0);
});
if (labels.length && maximum_scores.length && scores.length) {
frm.dashboard.render_graph({
data: {
labels: labels,
datasets: [
{
name: "Maximum Score",
chartType: "bar",
values: maximum_scores,
},
{
name: "Score Obtained",
chartType: "bar",
values: scores,
},
],
},
title: __("Scores"),
height: 250,
type: "bar",
barOptions: {
spaceRatio: 0.7,
},
colors: ["blue", "green"],
});
}
},
calculate_total(frm) {
let total = 0;
frm.doc.goals.forEach((d) => {
total += flt(d.score_earned);
});
frm.set_value("total_score", total);
},
});
frappe.ui.form.on("Appraisal Goal", {
score(frm, cdt, cdn) {
let d = frappe.get_doc(cdt, cdn);
if (flt(d.score) > 5) {
frappe.msgprint(__("Score must be less than or equal to 5"));
d.score = 0;
refresh_field("score", d.name, "goals");
} else {
frm.trigger("set_score_earned", cdt, cdn);
}
},
per_weightage(frm, cdt, cdn) {
frm.trigger("set_score_earned", cdt, cdn);
},
goals_remove(frm, cdt, cdn) {
frm.trigger("set_score_earned", cdt, cdn);
},
set_score_earned(frm, cdt, cdn) {
let d = frappe.get_doc(cdt, cdn);
let score_earned = (flt(d.score) * flt(d.per_weightage)) / 100;
frappe.model.set_value(cdt, cdn, "score_earned", score_earned);
frm.trigger("calculate_total");
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal/appraisal.js
|
JavaScript
|
agpl-3.0
| 3,467
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.query_builder.functions import Avg
from frappe.utils import flt, get_link_to_form, now
from hrms.hr.doctype.appraisal_cycle.appraisal_cycle import validate_active_appraisal_cycle
from hrms.hr.utils import validate_active_employee
from hrms.mixins.appraisal import AppraisalMixin
from hrms.payroll.utils import sanitize_expression
class Appraisal(Document, AppraisalMixin):
def validate(self):
if not self.status:
self.status = "Draft"
self.set_kra_evaluation_method()
validate_active_employee(self.employee)
validate_active_appraisal_cycle(self.appraisal_cycle)
self.validate_duplicate()
self.validate_total_weightage("appraisal_kra", "KRAs")
self.validate_total_weightage("self_ratings", "Self Ratings")
self.set_goal_score()
self.calculate_self_appraisal_score()
self.calculate_avg_feedback_score()
self.calculate_final_score()
def validate_duplicate(self):
Appraisal = frappe.qb.DocType("Appraisal")
duplicate = (
frappe.qb.from_(Appraisal)
.select(Appraisal.name)
.where(
(Appraisal.employee == self.employee)
& (Appraisal.docstatus != 2)
& (Appraisal.name != self.name)
& (
(Appraisal.appraisal_cycle == self.appraisal_cycle)
| (
(Appraisal.start_date.between(self.start_date, self.end_date))
| (Appraisal.end_date.between(self.start_date, self.end_date))
| (
(self.start_date >= Appraisal.start_date)
& (self.start_date <= Appraisal.end_date)
)
| ((self.end_date >= Appraisal.start_date) & (self.end_date <= Appraisal.end_date))
)
)
)
).run()
duplicate = duplicate[0][0] if duplicate else 0
if duplicate:
frappe.throw(
_(
"Appraisal {0} already exists for Employee {1} for this Appraisal Cycle or overlapping period"
).format(get_link_to_form("Appraisal", duplicate), frappe.bold(self.employee_name)),
exc=frappe.DuplicateEntryError,
title=_("Duplicate Entry"),
)
def set_kra_evaluation_method(self):
if (
self.is_new()
and self.appraisal_cycle
and (
frappe.db.get_value("Appraisal Cycle", self.appraisal_cycle, "kra_evaluation_method")
== "Manual Rating"
)
):
self.rate_goals_manually = 1
@frappe.whitelist()
def set_appraisal_template(self):
"""Sets appraisal template from Appraisee table in Cycle"""
if not self.appraisal_cycle:
return
appraisal_template = frappe.db.get_value(
"Appraisee",
{
"employee": self.employee,
"parent": self.appraisal_cycle,
},
"appraisal_template",
)
if appraisal_template:
self.appraisal_template = appraisal_template
self.set_kras_and_rating_criteria()
@frappe.whitelist()
def set_kras_and_rating_criteria(self):
if not self.appraisal_template:
return
self.set("appraisal_kra", [])
self.set("self_ratings", [])
self.set("goals", [])
template = frappe.get_doc("Appraisal Template", self.appraisal_template)
for entry in template.goals:
table_name = "goals" if self.rate_goals_manually else "appraisal_kra"
self.append(
table_name,
{
"kra": entry.key_result_area,
"per_weightage": entry.per_weightage,
},
)
for entry in template.rating_criteria:
self.append(
"self_ratings",
{
"criteria": entry.criteria,
"per_weightage": entry.per_weightage,
},
)
return self
def calculate_total_score(self):
total_weightage, total, goal_score_percentage = 0, 0, 0
if self.rate_goals_manually:
table = _("Goals")
for entry in self.goals:
if flt(entry.score) > 5:
frappe.throw(_("Row {0}: Goal Score cannot be greater than 5").format(entry.idx))
entry.score_earned = flt(entry.score) * flt(entry.per_weightage) / 100
total += flt(entry.score_earned)
total_weightage += flt(entry.per_weightage)
else:
table = _("KRAs")
for entry in self.appraisal_kra:
goal_score_percentage += flt(entry.goal_score)
total_weightage += flt(entry.per_weightage)
self.goal_score_percentage = flt(goal_score_percentage, self.precision("goal_score_percentage"))
# convert goal score percentage to total score out of 5
total = flt(goal_score_percentage) / 20
if total_weightage and flt(total_weightage, 2) != 100.0:
frappe.throw(
_("Total weightage for all {0} must add up to 100. Currently, it is {1}%").format(
table, total_weightage
),
title=_("Incorrect Weightage Allocation"),
)
self.total_score = flt(total, self.precision("total_score"))
def calculate_self_appraisal_score(self):
total = 0
for entry in self.self_ratings:
score = flt(entry.rating) * 5 * flt(entry.per_weightage / 100)
total += flt(score)
self.self_score = flt(total, self.precision("self_score"))
def calculate_avg_feedback_score(self, update=False):
avg_feedback_score = frappe.qb.avg(
"Employee Performance Feedback",
"total_score",
{"employee": self.employee, "appraisal": self.name, "docstatus": 1},
)
self.avg_feedback_score = flt(avg_feedback_score, self.precision("avg_feedback_score"))
if update:
self.calculate_final_score()
self.db_update()
def calculate_final_score(self):
final_score = 0
appraisal_cycle_doc = frappe.get_cached_doc("Appraisal Cycle", self.appraisal_cycle)
formula = appraisal_cycle_doc.final_score_formula
based_on_formula = appraisal_cycle_doc.calculate_final_score_based_on_formula
if based_on_formula:
employee_doc = frappe.get_cached_doc("Employee", self.employee)
data = {
"goal_score": flt(self.total_score),
"average_feedback_score": flt(self.avg_feedback_score),
"self_appraisal_score": flt(self.self_score),
}
data.update(appraisal_cycle_doc.as_dict())
data.update(employee_doc.as_dict())
data.update(self.as_dict())
sanitized_formula = sanitize_expression(formula)
final_score = frappe.safe_eval(sanitized_formula, data)
else:
final_score = (flt(self.total_score) + flt(self.avg_feedback_score) + flt(self.self_score)) / 3
self.final_score = flt(final_score, self.precision("final_score"))
@frappe.whitelist()
def add_feedback(self, feedback, feedback_ratings):
feedback = frappe.get_doc(
{
"doctype": "Employee Performance Feedback",
"appraisal": self.name,
"employee": self.employee,
"added_on": now(),
"feedback": feedback,
"reviewer": frappe.db.get_value("Employee", {"user_id": frappe.session.user}),
}
)
for entry in feedback_ratings:
feedback.append(
"feedback_ratings",
{
"criteria": entry.get("criteria"),
"rating": entry.get("rating"),
"per_weightage": entry.get("per_weightage"),
},
)
feedback.submit()
return feedback
def set_goal_score(self, update=False):
for kra in self.appraisal_kra:
# update progress for all goals as KRA linked could be removed or changed
Goal = frappe.qb.DocType("Goal")
avg_goal_completion = (
frappe.qb.from_(Goal)
.select(Avg(Goal.progress).as_("avg_goal_completion"))
.where(
(Goal.kra == kra.kra)
& (Goal.employee == self.employee)
# archived goals should not contribute to progress
& (Goal.status != "Archived")
& ((Goal.parent_goal == "") | (Goal.parent_goal.isnull()))
& (Goal.appraisal_cycle == self.appraisal_cycle)
)
).run()[0][0]
kra.goal_completion = flt(avg_goal_completion, kra.precision("goal_completion"))
kra.goal_score = flt(kra.goal_completion * kra.per_weightage / 100, kra.precision("goal_score"))
if update:
kra.db_update()
self.calculate_total_score()
if update:
self.calculate_final_score()
self.db_update()
return self
@frappe.whitelist()
def get_feedback_history(employee, appraisal):
data = frappe._dict()
data.feedback_history = frappe.get_list(
"Employee Performance Feedback",
filters={"employee": employee, "appraisal": appraisal, "docstatus": 1},
fields=[
"feedback",
"reviewer",
"user",
"owner",
"reviewer_name",
"reviewer_designation",
"added_on",
"employee",
"total_score",
"name",
],
order_by="added_on desc",
)
# get percentage of reviews per rating
reviews_per_rating = []
feedback_count = frappe.db.count(
"Employee Performance Feedback",
filters={
"appraisal": appraisal,
"employee": employee,
"docstatus": 1,
},
)
for i in range(1, 6):
count = frappe.db.count(
"Employee Performance Feedback",
filters={
"appraisal": appraisal,
"employee": employee,
"total_score": ("between", [i, i + 0.99]),
"docstatus": 1,
},
)
percent = flt((count / feedback_count) * 100, 0) if feedback_count else 0
reviews_per_rating.append(percent)
data.reviews_per_rating = reviews_per_rating
data.avg_feedback_score = frappe.db.get_value("Appraisal", appraisal, "avg_feedback_score")
return data
@frappe.whitelist()
@frappe.validate_and_sanitize_search_inputs
def get_kras_for_employee(doctype, txt, searchfield, start, page_len, filters):
appraisal = frappe.db.get_value(
"Appraisal",
{
"appraisal_cycle": filters.get("appraisal_cycle"),
"employee": filters.get("employee"),
},
"name",
)
return frappe.get_all(
"Appraisal KRA",
filters={"parent": appraisal, "kra": ("like", f"{txt}%")},
fields=["kra"],
as_list=1,
)
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal/appraisal.py
|
Python
|
agpl-3.0
| 9,422
|
// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Appraisal Cycle", {
refresh(frm) {
frm.set_query("department", () => {
return {
filters: {
company: frm.doc.company,
},
};
});
frm.trigger("show_custom_buttons");
frm.trigger("show_appraisal_summary");
frm.trigger("set_autocompletions_for_final_score_formula");
},
show_custom_buttons(frm) {
if (frm.doc.__islocal) return;
frm.add_custom_button(__("View Goals"), () => {
frappe.route_options = {
company: frm.doc.company,
appraisal_cycle: frm.doc.name,
};
frappe.set_route("Tree", "Goal");
});
let appraisals_created = frm.doc.__onload?.appraisals_created;
if (frm.doc.status !== "Completed") {
if (appraisals_created) {
frm.add_custom_button(__("Create Appraisals"), () => {
frm.trigger("create_appraisals");
});
} else {
frm.page.set_primary_action(__("Create Appraisals"), () => {
frm.trigger("create_appraisals");
});
}
}
if (frm.doc.status === "Not Started") {
if (appraisals_created) {
frm.page.set_primary_action(__("Start"), () => {
frm.set_value("status", "In Progress");
frm.save();
});
} else {
frm.add_custom_button(__("Start"), () => {
frm.set_value("status", "In Progress");
frm.save();
});
}
} else if (frm.doc.status === "In Progress") {
if (appraisals_created) {
frm.page.set_primary_action(__("Mark as Completed"), () => {
frm.trigger("complete_cycle");
});
} else {
frm.add_custom_button(__("Mark as Completed"), () => {
frm.trigger("complete_cycle");
});
}
} else if (frm.doc.status === "Completed") {
frm.add_custom_button(__("Mark as In Progress"), () => {
frm.set_value("status", "In Progress");
frm.save();
});
}
},
set_autocompletions_for_final_score_formula: async (frm) => {
const autocompletions = [
{
value: "goal_score",
score: 10,
meta: __("Total Goal Score"),
},
{
value: "average_feedback_score",
score: 10,
meta: __("Average Feedback Score"),
},
{
value: "self_appraisal_score",
score: 10,
meta: __("Self Appraisal Score"),
},
];
await Promise.all(
["Employee", "Appraisal Cycle", "Appraisal"].map((doctype) =>
frappe.model.with_doctype(doctype, () => {
autocompletions.push(...hrms.get_doctype_fields_for_autocompletion(doctype));
}),
),
);
frm.set_df_property("final_score_formula", "autocompletions", autocompletions);
},
get_employees(frm) {
frappe.call({
method: "set_employees",
doc: frm.doc,
freeze: true,
freeze_message: __("Fetching Employees"),
callback: function () {
refresh_field("appraisees");
frm.dirty();
},
});
},
create_appraisals(frm) {
frm.call({
method: "create_appraisals",
doc: frm.doc,
freeze: true,
}).then((r) => {
if (!r.exc) {
frm.reload_doc();
}
});
},
complete_cycle(frm) {
let msg = __(
"This action will prevent making changes to the linked appraisal feedback/goals.",
);
msg += "<br>";
msg += __("Are you sure you want to proceed?");
frappe.confirm(msg, () => {
frm.call({
method: "complete_cycle",
doc: frm.doc,
freeze: true,
}).then((r) => {
if (!r.exc) {
frm.reload_doc();
}
});
});
},
show_appraisal_summary(frm) {
if (frm.doc.__islocal) return;
frappe
.call("hrms.hr.doctype.appraisal_cycle.appraisal_cycle.get_appraisal_cycle_summary", {
cycle_name: frm.doc.name,
})
.then((r) => {
if (r.message) {
frm.dashboard.add_indicator(
__("Appraisees: {0}", [r.message.appraisees]),
"blue",
);
frm.dashboard.add_indicator(
__("Self Appraisal Pending: {0}", [r.message.self_appraisal_pending]),
"orange",
);
frm.dashboard.add_indicator(
__("Employees without Feedback: {0}", [r.message.feedback_missing]),
"orange",
);
frm.dashboard.add_indicator(
__("Employees without Goals: {0}", [r.message.goals_missing]),
"orange",
);
}
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_cycle/appraisal_cycle.js
|
JavaScript
|
agpl-3.0
| 4,169
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.query_builder.functions import Count
from frappe.query_builder.terms import SubQuery
class AppraisalCycle(Document):
def onload(self):
self.set_onload("appraisals_created", self.check_if_appraisals_exist())
def validate(self):
self.validate_from_to_dates("start_date", "end_date")
self.validate_evaluation_method_change()
def validate_evaluation_method_change(self):
if self.is_new():
return
if self.has_value_changed("kra_evaluation_method") and self.check_if_appraisals_exist():
frappe.throw(
_(
"Evaluation Method cannot be changed as there are existing appraisals created for this cycle"
),
title=_("Not Allowed"),
)
def check_if_appraisals_exist(self):
return frappe.db.exists(
"Appraisal",
{"appraisal_cycle": self.name, "docstatus": ["!=", 2]},
)
@frappe.whitelist()
def set_employees(self):
"""Pull employees in appraisee list based on selected filters"""
employees = self.get_employees_for_appraisal()
appraisal_templates = self.get_appraisal_template_map()
if employees:
self.set("appraisees", [])
template_missing = False
for data in employees:
if not appraisal_templates.get(data.designation):
template_missing = True
self.append(
"appraisees",
{
"employee": data.name,
"employee_name": data.employee_name,
"branch": data.branch,
"designation": data.designation,
"department": data.department,
"appraisal_template": appraisal_templates.get(data.designation),
},
)
if template_missing:
self.show_missing_template_message()
else:
self.set("appraisees", [])
frappe.msgprint(_("No employees found for the selected criteria"))
return self
def get_employees_for_appraisal(self):
filters = {
"status": "Active",
"company": self.company,
}
if self.department:
filters["department"] = self.department
if self.branch:
filters["branch"] = self.branch
if self.designation:
filters["designation"] = self.designation
employees = frappe.db.get_all(
"Employee",
filters=filters,
fields=[
"name",
"employee_name",
"branch",
"designation",
"department",
],
)
return employees
def get_appraisal_template_map(self):
designations = frappe.get_all("Designation", fields=["name", "appraisal_template"])
appraisal_templates = frappe._dict()
for entry in designations:
appraisal_templates[entry.name] = entry.appraisal_template
return appraisal_templates
@frappe.whitelist()
def create_appraisals(self):
self.check_permission("write")
if not self.appraisees:
frappe.throw(
_("Please select employees to create appraisals for"), title=_("No Employees Selected")
)
if not all(appraisee.appraisal_template for appraisee in self.appraisees):
self.show_missing_template_message(raise_exception=True)
if len(self.appraisees) > 30:
frappe.enqueue(
create_appraisals_for_cycle,
queue="long",
timeout=600,
appraisal_cycle=self,
)
frappe.msgprint(
_("Appraisal creation is queued. It may take a few minutes."),
alert=True,
indicator="blue",
)
else:
create_appraisals_for_cycle(self, publish_progress=True)
# since this method is called via frm.call this doc needs to be updated manually
self.reload()
def show_missing_template_message(self, raise_exception=False):
msg = _("Appraisal Template not found for some designations.")
msg += "<br><br>"
msg += _(
"Please set the Appraisal Template for all the {0} or select the template in the Employees table below."
).format(f"""<a href='{frappe.utils.get_url_to_list("Designation")}'>Designations</a>""")
frappe.msgprint(
msg, title=_("Appraisal Template Missing"), indicator="yellow", raise_exception=raise_exception
)
@frappe.whitelist()
def complete_cycle(self):
self.check_permission("write")
draft_appraisals = frappe.db.count("Appraisal", {"appraisal_cycle": self.name, "docstatus": 0})
if draft_appraisals:
link = frappe.utils.get_url_to_list("Appraisal") + f"?status=Draft&appraisal_cycle={self.name}"
link = f"""<a href="{link}">documents</a>"""
msg = _("{0} Appraisal(s) are not submitted yet").format(frappe.bold(draft_appraisals))
msg += "<br><br>"
msg += _("Please submit the {0} before marking the cycle as Completed").format(link)
frappe.throw(msg, title=_("Unsubmitted Appraisals"))
self.status = "Completed"
self.save()
def create_appraisals_for_cycle(appraisal_cycle: AppraisalCycle, publish_progress: bool = False):
"""
Creates appraisals for employees in the appraisee list of appraisal cycle,
if not already created
"""
count = 0
for employee in appraisal_cycle.appraisees:
try:
appraisal = frappe.get_doc(
{
"doctype": "Appraisal",
"appraisal_template": employee.appraisal_template,
"employee": employee.employee,
"appraisal_cycle": appraisal_cycle.name,
}
)
appraisal.rate_goals_manually = (
1 if appraisal_cycle.kra_evaluation_method == "Manual Rating" else 0
)
appraisal.set_kras_and_rating_criteria()
appraisal.insert()
if publish_progress:
count += 1
frappe.publish_progress(
count * 100 / len(appraisal_cycle.appraisees), title=_("Creating Appraisals") + "..."
)
except frappe.DuplicateEntryError:
# already exists
pass
def validate_active_appraisal_cycle(appraisal_cycle: str) -> None:
if frappe.db.get_value("Appraisal Cycle", appraisal_cycle, "status") == "Completed":
msg = _("Cannot create or change transactions against an Appraisal Cycle with status {0}.").format(
frappe.bold(_("Completed"))
)
msg += "<br><br>"
msg += _("Set the status to {0} if required.").format(frappe.bold(_("In Progress")))
frappe.throw(msg, title=_("Not Allowed"))
@frappe.whitelist()
def get_appraisal_cycle_summary(cycle_name: str) -> dict:
summary = frappe._dict()
summary["appraisees"] = frappe.db.count(
"Appraisal", {"appraisal_cycle": cycle_name, "docstatus": ("!=", 2)}
)
summary["self_appraisal_pending"] = frappe.db.count(
"Appraisal", {"appraisal_cycle": cycle_name, "docstatus": 0, "self_score": 0}
)
summary["goals_missing"] = get_employees_without_goals(cycle_name)
summary["feedback_missing"] = get_employees_without_feedback(cycle_name)
return summary
def get_employees_without_goals(cycle_name: str) -> int:
Goal = frappe.qb.DocType("Goal")
Appraisal = frappe.qb.DocType("Appraisal")
count = Count("*").as_("count")
filtered_records = SubQuery(
frappe.qb.from_(Goal)
.select(Goal.employee)
.distinct()
.where((Goal.appraisal_cycle == cycle_name) & (Goal.status != "Archived"))
)
goals_missing = (
frappe.qb.from_(Appraisal)
.select(count)
.where(
(Appraisal.appraisal_cycle == cycle_name)
& (Appraisal.docstatus != 2)
& (Appraisal.employee.notin(filtered_records))
)
).run(as_dict=True)
return goals_missing[0].count
def get_employees_without_feedback(cycle_name: str) -> int:
Feedback = frappe.qb.DocType("Employee Performance Feedback")
Appraisal = frappe.qb.DocType("Appraisal")
count = Count("*").as_("count")
filtered_records = SubQuery(
frappe.qb.from_(Feedback)
.select(Feedback.employee)
.distinct()
.where((Feedback.appraisal_cycle == cycle_name) & (Feedback.docstatus == 1))
)
feedback_missing = (
frappe.qb.from_(Appraisal)
.select(count)
.where(
(Appraisal.appraisal_cycle == cycle_name)
& (Appraisal.docstatus != 2)
& (Appraisal.employee.notin(filtered_records))
)
).run(as_dict=True)
return feedback_missing[0].count
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_cycle/appraisal_cycle.py
|
Python
|
agpl-3.0
| 7,772
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from frappe.model.document import Document
class AppraisalGoal(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_goal/appraisal_goal.py
|
Python
|
agpl-3.0
| 211
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class AppraisalKRA(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_kra/appraisal_kra.py
|
Python
|
agpl-3.0
| 217
|
// Copyright (c) 2016, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Appraisal Template", {
setup(frm) {
frm.get_field("rating_criteria").grid.editable_fields = [
{ fieldname: "criteria", columns: 6 },
{ fieldname: "per_weightage", columns: 5 },
];
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_template/appraisal_template.js
|
JavaScript
|
agpl-3.0
| 340
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import flt
from hrms.mixins.appraisal import AppraisalMixin
class AppraisalTemplate(Document, AppraisalMixin):
def validate(self):
self.validate_total_weightage("goals", "KRAs")
self.validate_total_weightage("rating_criteria", "Criteria")
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_template/appraisal_template.py
|
Python
|
agpl-3.0
| 472
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from frappe.model.document import Document
class AppraisalTemplateGoal(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisal_template_goal/appraisal_template_goal.py
|
Python
|
agpl-3.0
| 219
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class Appraisee(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/appraisee/appraisee.py
|
Python
|
agpl-3.0
| 214
|
// Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and Contributors
// License: GNU General Public License v3. See license.txt
frappe.ui.form.on("Attendance", {
refresh(frm) {
if (frm.doc.__islocal && !frm.doc.attendance_date) {
frm.set_value("attendance_date", frappe.datetime.get_today());
}
frm.set_query("employee", () => {
return {
query: "erpnext.controllers.queries.employee_query",
};
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance/attendance.js
|
JavaScript
|
agpl-3.0
| 431
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import (
add_days,
cint,
cstr,
format_date,
get_datetime,
get_link_to_form,
getdate,
nowdate,
)
from hrms.hr.doctype.shift_assignment.shift_assignment import has_overlapping_timings
from hrms.hr.utils import (
get_holiday_dates_for_employee,
get_holidays_for_employee,
validate_active_employee,
)
class DuplicateAttendanceError(frappe.ValidationError):
pass
class OverlappingShiftAttendanceError(frappe.ValidationError):
pass
class Attendance(Document):
def validate(self):
from erpnext.controllers.status_updater import validate_status
validate_status(self.status, ["Present", "Absent", "On Leave", "Half Day", "Work From Home"])
validate_active_employee(self.employee)
self.validate_attendance_date()
self.validate_duplicate_record()
self.validate_overlapping_shift_attendance()
self.validate_employee_status()
self.check_leave_record()
def on_cancel(self):
self.unlink_attendance_from_checkins()
def validate_attendance_date(self):
date_of_joining = frappe.db.get_value("Employee", self.employee, "date_of_joining")
# leaves can be marked for future dates
if (
self.status != "On Leave"
and not self.leave_application
and getdate(self.attendance_date) > getdate(nowdate())
):
frappe.throw(
_("Attendance can not be marked for future dates: {0}").format(
frappe.bold(format_date(self.attendance_date)),
)
)
elif date_of_joining and getdate(self.attendance_date) < getdate(date_of_joining):
frappe.throw(
_("Attendance date {0} can not be less than employee {1}'s joining date: {2}").format(
frappe.bold(format_date(self.attendance_date)),
frappe.bold(self.employee),
frappe.bold(format_date(date_of_joining)),
)
)
def validate_duplicate_record(self):
duplicate = self.get_duplicate_attendance_record()
if duplicate:
frappe.throw(
_("Attendance for employee {0} is already marked for the date {1}: {2}").format(
frappe.bold(self.employee),
frappe.bold(format_date(self.attendance_date)),
get_link_to_form("Attendance", duplicate),
),
title=_("Duplicate Attendance"),
exc=DuplicateAttendanceError,
)
def get_duplicate_attendance_record(self) -> str | None:
Attendance = frappe.qb.DocType("Attendance")
query = (
frappe.qb.from_(Attendance)
.select(Attendance.name)
.where(
(Attendance.employee == self.employee)
& (Attendance.docstatus < 2)
& (Attendance.attendance_date == self.attendance_date)
& (Attendance.name != self.name)
)
.for_update()
)
if self.shift:
query = query.where(
((Attendance.shift.isnull()) | (Attendance.shift == ""))
| (
((Attendance.shift.isnotnull()) | (Attendance.shift != ""))
& (Attendance.shift == self.shift)
)
)
duplicate = query.run(pluck=True)
return duplicate[0] if duplicate else None
def validate_overlapping_shift_attendance(self):
attendance = self.get_overlapping_shift_attendance()
if attendance:
frappe.throw(
_("Attendance for employee {0} is already marked for an overlapping shift {1}: {2}").format(
frappe.bold(self.employee),
frappe.bold(attendance.shift),
get_link_to_form("Attendance", attendance.name),
),
title=_("Overlapping Shift Attendance"),
exc=OverlappingShiftAttendanceError,
)
def get_overlapping_shift_attendance(self) -> dict:
if not self.shift:
return {}
Attendance = frappe.qb.DocType("Attendance")
same_date_attendance = (
frappe.qb.from_(Attendance)
.select(Attendance.name, Attendance.shift)
.where(
(Attendance.employee == self.employee)
& (Attendance.docstatus < 2)
& (Attendance.attendance_date == self.attendance_date)
& (Attendance.shift != self.shift)
& (Attendance.name != self.name)
)
).run(as_dict=True)
for d in same_date_attendance:
if has_overlapping_timings(self.shift, d.shift):
return d
return {}
def validate_employee_status(self):
if frappe.db.get_value("Employee", self.employee, "status") == "Inactive":
frappe.throw(_("Cannot mark attendance for an Inactive employee {0}").format(self.employee))
def check_leave_record(self):
LeaveApplication = frappe.qb.DocType("Leave Application")
leave_record = (
frappe.qb.from_(LeaveApplication)
.select(
LeaveApplication.leave_type,
LeaveApplication.half_day,
LeaveApplication.half_day_date,
LeaveApplication.name,
)
.where(
(LeaveApplication.employee == self.employee)
& (self.attendance_date >= LeaveApplication.from_date)
& (self.attendance_date <= LeaveApplication.to_date)
& (LeaveApplication.status == "Approved")
& (LeaveApplication.docstatus == 1)
)
).run(as_dict=True)
if leave_record:
for d in leave_record:
self.leave_type = d.leave_type
self.leave_application = d.name
if d.half_day_date == getdate(self.attendance_date):
self.status = "Half Day"
frappe.msgprint(
_("Employee {0} on Half day on {1}").format(
self.employee, format_date(self.attendance_date)
)
)
else:
self.status = "On Leave"
frappe.msgprint(
_("Employee {0} is on Leave on {1}").format(
self.employee, format_date(self.attendance_date)
)
)
if self.status in ("On Leave", "Half Day"):
if not leave_record:
frappe.msgprint(
_("No leave record found for employee {0} on {1}").format(
self.employee, format_date(self.attendance_date)
),
alert=1,
)
elif self.leave_type:
self.leave_type = None
self.leave_application = None
def validate_employee(self):
emp = frappe.db.sql(
"select name from `tabEmployee` where name = %s and status = 'Active'", self.employee
)
if not emp:
frappe.throw(_("Employee {0} is not active or does not exist").format(self.employee))
def unlink_attendance_from_checkins(self):
EmployeeCheckin = frappe.qb.DocType("Employee Checkin")
linked_logs = (
frappe.qb.from_(EmployeeCheckin)
.select(EmployeeCheckin.name)
.where(EmployeeCheckin.attendance == self.name)
.for_update()
.run(as_dict=True)
)
if linked_logs:
(
frappe.qb.update(EmployeeCheckin)
.set("attendance", "")
.where(EmployeeCheckin.attendance == self.name)
).run()
frappe.msgprint(
msg=_("Unlinked Attendance record from Employee Checkins: {}").format(
", ".join(get_link_to_form("Employee Checkin", log.name) for log in linked_logs)
),
title=_("Unlinked logs"),
indicator="blue",
is_minimizable=True,
wide=True,
)
@frappe.whitelist()
def get_events(start, end, filters=None):
from frappe.desk.reportview import get_filters_cond
events = []
employee = frappe.db.get_value("Employee", {"user_id": frappe.session.user})
if not employee:
return events
conditions = get_filters_cond("Attendance", filters, [])
add_attendance(events, start, end, conditions=conditions)
add_holidays(events, start, end, employee)
return events
def add_attendance(events, start, end, conditions=None):
query = """select name, attendance_date, status, employee_name
from `tabAttendance` where
attendance_date between %(from_date)s and %(to_date)s
and docstatus < 2"""
if conditions:
query += conditions
for d in frappe.db.sql(query, {"from_date": start, "to_date": end}, as_dict=True):
e = {
"name": d.name,
"doctype": "Attendance",
"start": d.attendance_date,
"end": d.attendance_date,
"title": f"{d.employee_name}: {cstr(d.status)}",
"status": d.status,
"docstatus": d.docstatus,
}
if e not in events:
events.append(e)
def add_holidays(events, start, end, employee=None):
holidays = get_holidays_for_employee(employee, start, end)
if not holidays:
return
for holiday in holidays:
events.append(
{
"doctype": "Holiday",
"start": holiday.holiday_date,
"end": holiday.holiday_date,
"title": _("Holiday") + ": " + cstr(holiday.description),
"name": holiday.name,
"allDay": 1,
}
)
def mark_attendance(
employee,
attendance_date,
status,
shift=None,
leave_type=None,
late_entry=False,
early_exit=False,
):
savepoint = "attendance_creation"
try:
frappe.db.savepoint(savepoint)
attendance = frappe.new_doc("Attendance")
attendance.update(
{
"doctype": "Attendance",
"employee": employee,
"attendance_date": attendance_date,
"status": status,
"shift": shift,
"leave_type": leave_type,
"late_entry": late_entry,
"early_exit": early_exit,
}
)
attendance.insert()
attendance.submit()
except (DuplicateAttendanceError, OverlappingShiftAttendanceError):
frappe.db.rollback(save_point=savepoint)
return
return attendance.name
@frappe.whitelist()
def mark_bulk_attendance(data):
import json
if isinstance(data, str):
data = json.loads(data)
data = frappe._dict(data)
if not data.unmarked_days:
frappe.throw(_("Please select a date."))
return
for date in data.unmarked_days:
doc_dict = {
"doctype": "Attendance",
"employee": data.employee,
"attendance_date": get_datetime(date),
"status": data.status,
}
attendance = frappe.get_doc(doc_dict).insert()
attendance.submit()
@frappe.whitelist()
def get_unmarked_days(employee, from_date, to_date, exclude_holidays=0):
joining_date, relieving_date = frappe.get_cached_value(
"Employee", employee, ["date_of_joining", "relieving_date"]
)
from_date = max(getdate(from_date), joining_date or getdate(from_date))
to_date = min(getdate(to_date), relieving_date or getdate(to_date))
records = frappe.get_all(
"Attendance",
fields=["attendance_date", "employee"],
filters=[
["attendance_date", ">=", from_date],
["attendance_date", "<=", to_date],
["employee", "=", employee],
["docstatus", "!=", 2],
],
)
marked_days = [getdate(record.attendance_date) for record in records]
if cint(exclude_holidays):
holiday_dates = get_holiday_dates_for_employee(employee, from_date, to_date)
holidays = [getdate(record) for record in holiday_dates]
marked_days.extend(holidays)
unmarked_days = []
while from_date <= to_date:
if from_date not in marked_days:
unmarked_days.append(from_date)
from_date = add_days(from_date, 1)
return unmarked_days
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance/attendance.py
|
Python
|
agpl-3.0
| 10,435
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.views.calendar["Attendance"] = {
field_map: {
start: "start",
end: "end",
id: "name",
title: "title",
allDay: "allDay",
color: "color",
},
get_css_class: function (data) {
if (data.doctype === "Holiday") return "default";
else if (data.doctype === "Attendance") {
if (data.status === "Absent" || data.status === "On Leave") {
return "danger";
}
if (data.status === "Half Day") return "warning";
return "success";
}
},
options: {
header: {
left: "prev,next today",
center: "title",
right: "month",
},
},
get_events_method: "hrms.hr.doctype.attendance.attendance.get_events",
};
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance/attendance_calendar.js
|
JavaScript
|
agpl-3.0
| 759
|
def get_data():
return {"fieldname": "attendance", "transactions": [{"label": "", "items": ["Employee Checkin"]}]}
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance/attendance_dashboard.py
|
Python
|
agpl-3.0
| 116
|
frappe.listview_settings["Attendance"] = {
add_fields: ["status", "attendance_date"],
get_indicator: function (doc) {
if (["Present", "Work From Home"].includes(doc.status)) {
return [__(doc.status), "green", "status,=," + doc.status];
} else if (["Absent", "On Leave"].includes(doc.status)) {
return [__(doc.status), "red", "status,=," + doc.status];
} else if (doc.status == "Half Day") {
return [__(doc.status), "orange", "status,=," + doc.status];
}
},
onload: function (list_view) {
let me = this;
list_view.page.add_inner_button(__("Mark Attendance"), function () {
let first_day_of_month = moment().startOf("month");
if (moment().toDate().getDate() === 1) {
first_day_of_month = first_day_of_month.subtract(1, "month");
}
let dialog = new frappe.ui.Dialog({
title: __("Mark Attendance"),
fields: [
{
fieldname: "employee",
label: __("For Employee"),
fieldtype: "Link",
options: "Employee",
get_query: () => {
return {
query: "erpnext.controllers.queries.employee_query",
};
},
reqd: 1,
onchange: () => me.reset_dialog(dialog),
},
{
fieldtype: "Section Break",
fieldname: "time_period_section",
hidden: 1,
},
{
label: __("Start"),
fieldtype: "Date",
fieldname: "from_date",
reqd: 1,
default: first_day_of_month.toDate(),
onchange: () => me.get_unmarked_days(dialog),
},
{
fieldtype: "Column Break",
fieldname: "time_period_column",
},
{
label: __("End"),
fieldtype: "Date",
fieldname: "to_date",
reqd: 1,
default: moment().subtract(1, "days").toDate(),
onchange: () => me.get_unmarked_days(dialog),
},
{
fieldtype: "Section Break",
fieldname: "days_section",
hidden: 1,
},
{
label: __("Status"),
fieldtype: "Select",
fieldname: "status",
options: ["Present", "Absent", "Half Day", "Work From Home"],
reqd: 1,
},
{
label: __("Exclude Holidays"),
fieldtype: "Check",
fieldname: "exclude_holidays",
onchange: () => me.get_unmarked_days(dialog),
},
{
label: __("Unmarked Attendance for days"),
fieldname: "unmarked_days",
fieldtype: "MultiCheck",
options: [],
columns: 2,
select_all: true,
},
],
primary_action(data) {
if (cur_dialog.no_unmarked_days_left) {
frappe.msgprint(
__(
"Attendance from {0} to {1} has already been marked for the Employee {2}",
[data.from_date, data.to_date, data.employee],
),
);
} else {
frappe.confirm(
__("Mark attendance as {0} for {1} on selected dates?", [
data.status,
data.employee,
]),
() => {
frappe.call({
method: "hrms.hr.doctype.attendance.attendance.mark_bulk_attendance",
args: {
data: data,
},
callback: function (r) {
if (r.message === 1) {
frappe.show_alert({
message: __("Attendance Marked"),
indicator: "blue",
});
cur_dialog.hide();
}
},
});
},
);
}
dialog.hide();
list_view.refresh();
},
primary_action_label: __("Mark Attendance"),
});
dialog.show();
});
},
reset_dialog: function (dialog) {
let fields = dialog.fields_dict;
dialog.set_df_property("time_period_section", "hidden", fields.employee.value ? 0 : 1);
dialog.set_df_property("days_section", "hidden", 1);
dialog.set_df_property("unmarked_days", "options", []);
dialog.no_unmarked_days_left = false;
fields.exclude_holidays.value = false;
fields.to_date.datepicker.update({
maxDate: moment().subtract(1, "days").toDate(),
});
this.get_unmarked_days(dialog);
},
get_unmarked_days: function (dialog) {
let fields = dialog.fields_dict;
if (fields.employee.value && fields.from_date.value && fields.to_date.value) {
dialog.set_df_property("days_section", "hidden", 0);
dialog.set_df_property("status", "hidden", 0);
dialog.set_df_property("exclude_holidays", "hidden", 0);
dialog.no_unmarked_days_left = false;
frappe
.call({
method: "hrms.hr.doctype.attendance.attendance.get_unmarked_days",
async: false,
args: {
employee: fields.employee.value,
from_date: fields.from_date.value,
to_date: fields.to_date.value,
exclude_holidays: fields.exclude_holidays.value,
},
})
.then((r) => {
var options = [];
for (var d in r.message) {
var momentObj = moment(r.message[d], "YYYY-MM-DD");
var date = momentObj.format("DD-MM-YYYY");
options.push({
label: date,
value: r.message[d],
checked: 1,
});
}
dialog.set_df_property(
"unmarked_days",
"options",
options.length > 0 ? options : [],
);
dialog.no_unmarked_days_left = options.length === 0;
});
}
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance/attendance_list.js
|
JavaScript
|
agpl-3.0
| 5,083
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Attendance Request", {
refresh(frm) {
frm.trigger("show_attendance_warnings");
},
show_attendance_warnings(frm) {
if (!frm.is_new() && frm.doc.docstatus === 0) {
frm.dashboard.clear_headline();
frm.call("get_attendance_warnings").then((r) => {
if (r.message?.length) {
frm.dashboard.reset();
frm.dashboard.add_section(
frappe.render_template("attendance_warnings", {
warnings: r.message || [],
}),
__("Attendance Warnings"),
);
frm.dashboard.show();
}
});
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance_request/attendance_request.js
|
JavaScript
|
agpl-3.0
| 679
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import add_days, date_diff, format_date, get_link_to_form, getdate
from erpnext.setup.doctype.employee.employee import is_holiday
from hrms.hr.utils import validate_active_employee, validate_dates
class OverlappingAttendanceRequestError(frappe.ValidationError):
pass
class AttendanceRequest(Document):
def validate(self):
validate_active_employee(self.employee)
validate_dates(self, self.from_date, self.to_date)
self.validate_half_day()
self.validate_request_overlap()
def validate_half_day(self):
if self.half_day:
if not getdate(self.from_date) <= getdate(self.half_day_date) <= getdate(self.to_date):
frappe.throw(_("Half day date should be in between from date and to date"))
def validate_request_overlap(self):
if not self.name:
self.name = "New Attendance Request"
Request = frappe.qb.DocType("Attendance Request")
overlapping_request = (
frappe.qb.from_(Request)
.select(Request.name)
.where(
(Request.employee == self.employee)
& (Request.docstatus < 2)
& (Request.name != self.name)
& (self.to_date >= Request.from_date)
& (self.from_date <= Request.to_date)
)
).run(as_dict=True)
if overlapping_request:
self.throw_overlap_error(overlapping_request[0].name)
def throw_overlap_error(self, overlapping_request: str):
msg = _("Employee {0} already has an Attendance Request {1} that overlaps with this period").format(
frappe.bold(self.employee),
get_link_to_form("Attendance Request", overlapping_request),
)
frappe.throw(msg, title=_("Overlapping Attendance Request"), exc=OverlappingAttendanceRequestError)
def on_submit(self):
self.create_attendance_records()
def on_cancel(self):
attendance_list = frappe.get_all(
"Attendance", {"employee": self.employee, "attendance_request": self.name, "docstatus": 1}
)
if attendance_list:
for attendance in attendance_list:
attendance_obj = frappe.get_doc("Attendance", attendance["name"])
attendance_obj.cancel()
def create_attendance_records(self):
request_days = date_diff(self.to_date, self.from_date) + 1
for day in range(request_days):
attendance_date = add_days(self.from_date, day)
if self.should_mark_attendance(attendance_date):
self.create_or_update_attendance(attendance_date)
def create_or_update_attendance(self, date: str):
attendance_name = self.get_attendance_record(date)
status = self.get_attendance_status(date)
if attendance_name:
# update existing attendance, change the status
doc = frappe.get_doc("Attendance", attendance_name)
old_status = doc.status
if old_status != status:
doc.db_set({"status": status, "attendance_request": self.name})
text = _("changed the status from {0} to {1} via Attendance Request").format(
frappe.bold(old_status), frappe.bold(status)
)
doc.add_comment(comment_type="Info", text=text)
frappe.msgprint(
_("Updated status from {0} to {1} for date {2} in the attendance record {3}").format(
frappe.bold(old_status),
frappe.bold(status),
frappe.bold(format_date(date)),
get_link_to_form("Attendance", doc.name),
),
title=_("Attendance Updated"),
)
else:
# submit a new attendance record
doc = frappe.new_doc("Attendance")
doc.employee = self.employee
doc.attendance_date = date
doc.shift = self.shift
doc.company = self.company
doc.attendance_request = self.name
doc.status = status
doc.insert(ignore_permissions=True)
doc.submit()
def should_mark_attendance(self, attendance_date: str) -> bool:
# Check if attendance_date is a holiday
if not self.include_holidays and is_holiday(self.employee, attendance_date):
frappe.msgprint(
_("Attendance not submitted for {0} as it is a Holiday.").format(
frappe.bold(format_date(attendance_date))
)
)
return False
# Check if employee is on leave
if self.has_leave_record(attendance_date):
frappe.msgprint(
_("Attendance not submitted for {0} as {1} is on leave.").format(
frappe.bold(format_date(attendance_date)), frappe.bold(self.employee)
)
)
return False
return True
def has_leave_record(self, attendance_date: str) -> str | None:
return frappe.db.exists(
"Leave Application",
{
"employee": self.employee,
"docstatus": 1,
"from_date": ("<=", attendance_date),
"to_date": (">=", attendance_date),
"status": "Approved",
},
)
def get_attendance_record(self, attendance_date: str) -> str | None:
return frappe.db.exists(
"Attendance",
{
"employee": self.employee,
"attendance_date": attendance_date,
"docstatus": ("!=", 2),
},
)
def get_attendance_status(self, attendance_date: str) -> str:
if self.half_day and date_diff(getdate(self.half_day_date), getdate(attendance_date)) == 0:
return "Half Day"
elif self.reason == "Work From Home":
return "Work From Home"
else:
return "Present"
@frappe.whitelist()
def get_attendance_warnings(self) -> list:
attendance_warnings = []
request_days = date_diff(self.to_date, self.from_date) + 1
for day in range(request_days):
attendance_date = add_days(self.from_date, day)
if not self.include_holidays and is_holiday(self.employee, attendance_date):
attendance_warnings.append({"date": attendance_date, "reason": "Holiday", "action": "Skip"})
elif self.has_leave_record(attendance_date):
attendance_warnings.append({"date": attendance_date, "reason": "On Leave", "action": "Skip"})
else:
attendance = self.get_attendance_record(attendance_date)
if attendance:
attendance_warnings.append(
{
"date": attendance_date,
"reason": "Attendance already marked",
"record": attendance,
"action": "Overwrite",
}
)
return attendance_warnings
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance_request/attendance_request.py
|
Python
|
agpl-3.0
| 6,016
|
def get_data():
return {"fieldname": "attendance_request", "transactions": [{"items": ["Attendance"]}]}
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance_request/attendance_request_dashboard.py
|
Python
|
agpl-3.0
| 105
|
<div class="form-message yellow">
<div>{{__("Attendance for the following dates will be skipped/overwritten on submission")}}</div>
</div>
<table class="table table-bordered table-hover">
<thead>
<tr>
<th style="width: 20%">{{ __("Date") }}</th>
<th style="width: 20%">{{ __("Action on Submission") }}</th>
<th style="width: 20%">{{ __("Reason") }}</th>
<th style="width: 20%">{{ __("Existing Record") }}</th>
</tr>
</thead>
<tbody>
{% for(var i=0; i < warnings.length; i++) { %}
<tr>
<td class="small">{{ frappe.datetime.str_to_user(warnings[i].date) }}</td>
<td class="small"> {{ __(warnings[i].action) }} </td>
<td class="small"> {{ __(warnings[i].reason) }} </td>
<td class="small"> {{ warnings[i].record }} </td>
</tr>
{% } %}
</tbody>
</table>
|
2302_79757062/hrms
|
hrms/hr/doctype/attendance_request/attendance_warnings.html
|
HTML
|
agpl-3.0
| 790
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Compensatory Leave Request", {
refresh: function (frm) {
frm.set_query("leave_type", function () {
return {
filters: {
is_compensatory: true,
},
};
});
},
half_day: function (frm) {
if (frm.doc.half_day == 1) {
frm.set_df_property("half_day_date", "reqd", true);
} else {
frm.set_df_property("half_day_date", "reqd", false);
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/compensatory_leave_request/compensatory_leave_request.js
|
JavaScript
|
agpl-3.0
| 514
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import add_days, cint, date_diff, format_date, get_url_to_list, getdate
from hrms.hr.utils import (
create_additional_leave_ledger_entry,
get_holiday_dates_for_employee,
get_leave_period,
validate_active_employee,
validate_dates,
validate_overlap,
)
class CompensatoryLeaveRequest(Document):
def validate(self):
validate_active_employee(self.employee)
validate_dates(self, self.work_from_date, self.work_end_date)
if self.half_day:
if not self.half_day_date:
frappe.throw(_("Half Day Date is mandatory"))
if not getdate(self.work_from_date) <= getdate(self.half_day_date) <= getdate(self.work_end_date):
frappe.throw(_("Half Day Date should be in between Work From Date and Work End Date"))
validate_overlap(self, self.work_from_date, self.work_end_date)
self.validate_holidays()
self.validate_attendance()
if not self.leave_type:
frappe.throw(_("Leave Type is mandatory"))
def validate_attendance(self):
attendance_records = frappe.get_all(
"Attendance",
filters={
"attendance_date": ["between", (self.work_from_date, self.work_end_date)],
"status": ("in", ["Present", "Work From Home", "Half Day"]),
"docstatus": 1,
"employee": self.employee,
},
fields=["attendance_date", "status"],
)
half_days = [entry.attendance_date for entry in attendance_records if entry.status == "Half Day"]
if half_days and (not self.half_day or getdate(self.half_day_date) not in half_days):
frappe.throw(
_(
"You were only present for Half Day on {}. Cannot apply for a full day compensatory leave"
).format(", ".join([frappe.bold(format_date(half_day)) for half_day in half_days]))
)
if len(attendance_records) < date_diff(self.work_end_date, self.work_from_date) + 1:
frappe.throw(_("You are not present all day(s) between compensatory leave request days"))
def validate_holidays(self):
holidays = get_holiday_dates_for_employee(self.employee, self.work_from_date, self.work_end_date)
if len(holidays) < date_diff(self.work_end_date, self.work_from_date) + 1:
if date_diff(self.work_end_date, self.work_from_date):
msg = _("The days between {0} to {1} are not valid holidays.").format(
frappe.bold(format_date(self.work_from_date)),
frappe.bold(format_date(self.work_end_date)),
)
else:
msg = _("{0} is not a holiday.").format(frappe.bold(format_date(self.work_from_date)))
frappe.throw(msg)
def on_submit(self):
company = frappe.db.get_value("Employee", self.employee, "company")
date_difference = date_diff(self.work_end_date, self.work_from_date) + 1
if self.half_day:
date_difference -= 0.5
comp_leave_valid_from = add_days(self.work_end_date, 1)
leave_period = get_leave_period(comp_leave_valid_from, comp_leave_valid_from, company)
if leave_period:
leave_allocation = self.get_existing_allocation_for_period(leave_period)
if leave_allocation:
leave_allocation.new_leaves_allocated += date_difference
leave_allocation.validate()
leave_allocation.db_set("new_leaves_allocated", leave_allocation.total_leaves_allocated)
leave_allocation.db_set("total_leaves_allocated", leave_allocation.total_leaves_allocated)
# generate additional ledger entry for the new compensatory leaves off
create_additional_leave_ledger_entry(leave_allocation, date_difference, comp_leave_valid_from)
else:
leave_allocation = self.create_leave_allocation(leave_period, date_difference)
self.db_set("leave_allocation", leave_allocation.name)
else:
comp_leave_valid_from = frappe.bold(format_date(comp_leave_valid_from))
msg = _("This compensatory leave will be applicable from {0}.").format(comp_leave_valid_from)
msg += " " + _(
"Currently, there is no {0} leave period for this date to create/update leave allocation."
).format(frappe.bold(_("active")))
msg += "<br><br>" + _("Please create a new {0} for the date {1} first.").format(
f"""<a href='{get_url_to_list("Leave Period")}'>Leave Period</a>""",
comp_leave_valid_from,
)
frappe.throw(msg, title=_("No Leave Period Found"))
def on_cancel(self):
if self.leave_allocation:
date_difference = date_diff(self.work_end_date, self.work_from_date) + 1
if self.half_day:
date_difference -= 0.5
leave_allocation = frappe.get_doc("Leave Allocation", self.leave_allocation)
if leave_allocation:
leave_allocation.new_leaves_allocated -= date_difference
if leave_allocation.new_leaves_allocated - date_difference <= 0:
leave_allocation.new_leaves_allocated = 0
leave_allocation.validate()
leave_allocation.db_set("new_leaves_allocated", leave_allocation.total_leaves_allocated)
leave_allocation.db_set("total_leaves_allocated", leave_allocation.total_leaves_allocated)
# create reverse entry on cancelation
create_additional_leave_ledger_entry(
leave_allocation, date_difference * -1, add_days(self.work_end_date, 1)
)
def get_existing_allocation_for_period(self, leave_period):
leave_allocation = frappe.db.sql(
"""
select name
from `tabLeave Allocation`
where employee=%(employee)s and leave_type=%(leave_type)s
and docstatus=1
and (from_date between %(from_date)s and %(to_date)s
or to_date between %(from_date)s and %(to_date)s
or (from_date < %(from_date)s and to_date > %(to_date)s))
""",
{
"from_date": leave_period[0].from_date,
"to_date": leave_period[0].to_date,
"employee": self.employee,
"leave_type": self.leave_type,
},
as_dict=1,
)
if leave_allocation:
return frappe.get_doc("Leave Allocation", leave_allocation[0].name)
else:
return False
def create_leave_allocation(self, leave_period, date_difference):
is_carry_forward = frappe.db.get_value("Leave Type", self.leave_type, "is_carry_forward")
allocation = frappe.get_doc(
dict(
doctype="Leave Allocation",
employee=self.employee,
employee_name=self.employee_name,
leave_type=self.leave_type,
from_date=add_days(self.work_end_date, 1),
to_date=leave_period[0].to_date,
carry_forward=cint(is_carry_forward),
new_leaves_allocated=date_difference,
total_leaves_allocated=date_difference,
description=self.reason,
)
)
allocation.insert(ignore_permissions=True)
allocation.submit()
return allocation
|
2302_79757062/hrms
|
hrms/hr/doctype/compensatory_leave_request/compensatory_leave_request.py
|
Python
|
agpl-3.0
| 6,521
|
// Copyright (c) 2016, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Daily Work Summary", {
refresh: function (frm) {},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/daily_work_summary/daily_work_summary.js
|
JavaScript
|
agpl-3.0
| 197
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from email_reply_parser import EmailReplyParser
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import global_date_format
class DailyWorkSummary(Document):
def send_mails(self, dws_group, emails):
"""Send emails to get daily work summary to all users \
in selected daily work summary group"""
incoming_email_account = frappe.db.get_value(
"Email Account", dict(enable_incoming=1, default_incoming=1), "email_id"
)
self.db_set("email_sent_to", "\n".join(emails))
frappe.sendmail(
recipients=emails,
message=dws_group.message,
subject=dws_group.subject,
reference_doctype=self.doctype,
reference_name=self.name,
reply_to=incoming_email_account,
)
def send_summary(self):
"""Send summary of all replies. Called at midnight"""
args = self.get_message_details()
emails = get_user_emails_from_group(self.daily_work_summary_group)
frappe.sendmail(
recipients=emails,
template="daily_work_summary",
args=args,
subject=_(self.daily_work_summary_group),
reference_doctype=self.doctype,
reference_name=self.name,
)
self.db_set("status", "Sent")
def get_message_details(self):
"""Return args for template"""
dws_group = frappe.get_doc("Daily Work Summary Group", self.daily_work_summary_group)
replies = frappe.get_all(
"Communication",
fields=["content", "text_content", "sender"],
filters=dict(
reference_doctype=self.doctype,
reference_name=self.name,
communication_type="Communication",
sent_or_received="Received",
),
order_by="creation asc",
)
did_not_reply = self.email_sent_to.split()
for d in replies:
user = frappe.db.get_values(
"User", {"email": d.sender}, ["full_name", "user_image"], as_dict=True
)
d.sender_name = user[0].full_name if user else d.sender
d.image = user[0].image if user and user[0].image else None
original_image = d.image
# make thumbnail image
try:
if original_image:
file_name = frappe.get_list("File", {"file_url": original_image})
if file_name:
file_name = file_name[0].name
file_doc = frappe.get_doc("File", file_name)
thumbnail_image = file_doc.make_thumbnail(
set_as_thumbnail=False, width=100, height=100, crop=True
)
d.image = thumbnail_image
except Exception:
d.image = original_image
if d.sender in did_not_reply:
did_not_reply.remove(d.sender)
if d.text_content:
d.content = frappe.utils.md_to_html(EmailReplyParser.parse_reply(d.text_content))
did_not_reply = [
(frappe.db.get_value("User", {"email": email}, "full_name") or email) for email in did_not_reply
]
return dict(
replies=replies,
original_message=dws_group.message,
title=_("Work Summary for {0}").format(global_date_format(self.creation)),
did_not_reply=", ".join(did_not_reply) or "",
did_not_reply_title=_("No replies from"),
)
def get_user_emails_from_group(group):
"""Returns list of email of enabled users from the given group
:param group: Daily Work Summary Group `name`"""
group_doc = group
if isinstance(group_doc, str):
group_doc = frappe.get_doc("Daily Work Summary Group", group)
emails = get_users_email(group_doc)
return emails
def get_users_email(doc):
return [d.email for d in doc.users if frappe.db.get_value("User", d.user, "enabled")]
|
2302_79757062/hrms
|
hrms/hr/doctype/daily_work_summary/daily_work_summary.py
|
Python
|
agpl-3.0
| 3,485
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Daily Work Summary Group", {
refresh: function (frm) {
if (!frm.is_new()) {
frm.add_custom_button(__("Daily Work Summary"), function () {
frappe.set_route("List", "Daily Work Summary");
});
}
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/daily_work_summary_group/daily_work_summary_group.js
|
JavaScript
|
agpl-3.0
| 356
|
# # Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
# # For license information, please see license.txt
import frappe
import frappe.utils
from frappe import _
from frappe.model.document import Document
from erpnext.setup.doctype.holiday_list.holiday_list import is_holiday
from hrms.hr.doctype.daily_work_summary.daily_work_summary import get_user_emails_from_group
class DailyWorkSummaryGroup(Document):
def validate(self):
if self.users:
if not frappe.flags.in_test and not is_incoming_account_enabled():
frappe.throw(
_("Please enable default incoming account before creating Daily Work Summary Group")
)
def trigger_emails():
"""Send emails to Employees at the given hour asking
them what did they work on today"""
groups = frappe.get_all("Daily Work Summary Group")
for d in groups:
group_doc = frappe.get_doc("Daily Work Summary Group", d)
if (
is_current_hour(group_doc.send_emails_at)
and not is_holiday(group_doc.holiday_list)
and group_doc.enabled
):
emails = get_user_emails_from_group(group_doc)
# find emails relating to a company
if emails:
daily_work_summary = frappe.get_doc(
dict(doctype="Daily Work Summary", daily_work_summary_group=group_doc.name)
).insert()
daily_work_summary.send_mails(group_doc, emails)
def is_current_hour(hour):
return frappe.utils.nowtime().split(":")[0] == hour.split(":")[0]
def send_summary():
"""Send summary to everyone"""
for d in frappe.get_all("Daily Work Summary", dict(status="Open")):
daily_work_summary = frappe.get_doc("Daily Work Summary", d.name)
daily_work_summary.send_summary()
def is_incoming_account_enabled():
return frappe.db.get_value("Email Account", dict(enable_incoming=1, default_incoming=1))
|
2302_79757062/hrms
|
hrms/hr/doctype/daily_work_summary_group/daily_work_summary_group.py
|
Python
|
agpl-3.0
| 1,769
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class DailyWorkSummaryGroupUser(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/daily_work_summary_group_user/daily_work_summary_group_user.py
|
Python
|
agpl-3.0
| 215
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import get_link_to_form
class DepartmentApprover(Document):
pass
@frappe.whitelist()
@frappe.validate_and_sanitize_search_inputs
def get_approvers(doctype, txt, searchfield, start, page_len, filters):
if not filters.get("employee"):
frappe.throw(_("Please select Employee first."))
approvers = []
department_details = {}
department_list = []
employee = frappe.get_value(
"Employee",
filters.get("employee"),
["employee_name", "department", "leave_approver", "expense_approver", "shift_request_approver"],
as_dict=True,
)
employee_department = filters.get("department") or employee.department
if employee_department:
department_details = frappe.db.get_value(
"Department", {"name": employee_department}, ["lft", "rgt"], as_dict=True
)
if department_details:
department_list = frappe.db.sql(
"""select name from `tabDepartment` where lft <= %s
and rgt >= %s
and disabled=0
order by lft desc""",
(department_details.lft, department_details.rgt),
as_list=True,
)
if filters.get("doctype") == "Leave Application" and employee.leave_approver:
approvers.append(
frappe.db.get_value("User", employee.leave_approver, ["name", "first_name", "last_name"])
)
if filters.get("doctype") == "Expense Claim" and employee.expense_approver:
approvers.append(
frappe.db.get_value("User", employee.expense_approver, ["name", "first_name", "last_name"])
)
if filters.get("doctype") == "Shift Request" and employee.shift_request_approver:
approvers.append(
frappe.db.get_value("User", employee.shift_request_approver, ["name", "first_name", "last_name"])
)
if filters.get("doctype") == "Leave Application":
parentfield = "leave_approvers"
field_name = "Leave Approver"
elif filters.get("doctype") == "Expense Claim":
parentfield = "expense_approvers"
field_name = "Expense Approver"
elif filters.get("doctype") == "Shift Request":
parentfield = "shift_request_approver"
field_name = "Shift Request Approver"
if department_list:
for d in department_list:
approvers += frappe.db.sql(
"""select user.name, user.first_name, user.last_name from
tabUser user, `tabDepartment Approver` approver where
approver.parent = %s
and user.name like %s
and approver.parentfield = %s
and approver.approver=user.name""",
(d, "%" + txt + "%", parentfield),
as_list=True,
)
if len(approvers) == 0:
error_msg = _("Please set {0} for the Employee: {1}").format(
frappe.bold(_(field_name)),
get_link_to_form("Employee", filters.get("employee"), employee.employee_name),
)
if department_list:
error_msg += " " + _("or for the Employee's Department: {0}").format(
get_link_to_form("Department", employee_department)
)
frappe.throw(error_msg, title=_("{0} Missing").format(_(field_name)))
return set(tuple(approver) for approver in approvers)
|
2302_79757062/hrms
|
hrms/hr/doctype/department_approver/department_approver.py
|
Python
|
agpl-3.0
| 3,079
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class DesignationSkill(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/designation_skill/designation_skill.py
|
Python
|
agpl-3.0
| 222
|
// Copyright (c) 2017, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Advance", {
setup: function (frm) {
frm.set_query("employee", function () {
return {
filters: {
status: "Active",
},
};
});
frm.set_query("advance_account", function () {
if (!frm.doc.employee) {
frappe.msgprint(__("Please select employee first"));
}
let company_currency = erpnext.get_currency(frm.doc.company);
let currencies = [company_currency];
if (frm.doc.currency && frm.doc.currency != company_currency) {
currencies.push(frm.doc.currency);
}
return {
filters: {
root_type: "Asset",
is_group: 0,
company: frm.doc.company,
account_currency: ["in", currencies],
},
};
});
frm.set_query("salary_component", function () {
return {
filters: {
type: "Deduction",
},
};
});
},
refresh: function (frm) {
if (
frm.doc.docstatus === 1 &&
flt(frm.doc.paid_amount) < flt(frm.doc.advance_amount) &&
frappe.model.can_create("Payment Entry")
) {
frm.add_custom_button(
__("Payment"),
function () {
frm.events.make_payment_entry(frm);
},
__("Create"),
);
} else if (
frm.doc.docstatus === 1 &&
flt(frm.doc.claimed_amount) < flt(frm.doc.paid_amount) - flt(frm.doc.return_amount) &&
frappe.model.can_create("Expense Claim")
) {
frm.add_custom_button(
__("Expense Claim"),
function () {
frm.events.make_expense_claim(frm);
},
__("Create"),
);
}
if (
frm.doc.docstatus === 1 &&
flt(frm.doc.claimed_amount) < flt(frm.doc.paid_amount) - flt(frm.doc.return_amount)
) {
if (
frm.doc.repay_unclaimed_amount_from_salary == 0 &&
frappe.model.can_create("Journal Entry")
) {
frm.add_custom_button(
__("Return"),
function () {
frm.trigger("make_return_entry");
},
__("Create"),
);
} else if (
frm.doc.repay_unclaimed_amount_from_salary == 1 &&
frappe.model.can_create("Additional Salary")
) {
frm.add_custom_button(
__("Deduction from Salary"),
function () {
frm.events.make_deduction_via_additional_salary(frm);
},
__("Create"),
);
}
}
},
make_deduction_via_additional_salary: function (frm) {
frappe.call({
method: "hrms.hr.doctype.employee_advance.employee_advance.create_return_through_additional_salary",
args: {
doc: frm.doc,
},
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
make_payment_entry: function (frm) {
let method = "hrms.overrides.employee_payment_entry.get_payment_entry_for_employee";
if (frm.doc.__onload && frm.doc.__onload.make_payment_via_journal_entry) {
method = "hrms.hr.doctype.employee_advance.employee_advance.make_bank_entry";
}
return frappe.call({
method: method,
args: {
dt: frm.doc.doctype,
dn: frm.doc.name,
},
callback: function (r) {
var doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
make_expense_claim: function (frm) {
return frappe.call({
method: "hrms.hr.doctype.expense_claim.expense_claim.get_expense_claim",
args: {
employee_name: frm.doc.employee,
company: frm.doc.company,
employee_advance_name: frm.doc.name,
posting_date: frm.doc.posting_date,
paid_amount: frm.doc.paid_amount,
claimed_amount: frm.doc.claimed_amount,
},
callback: function (r) {
const doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
make_return_entry: function (frm) {
frappe.call({
method: "hrms.hr.doctype.employee_advance.employee_advance.make_return_entry",
args: {
employee: frm.doc.employee,
company: frm.doc.company,
employee_advance_name: frm.doc.name,
return_amount: flt(frm.doc.paid_amount - frm.doc.claimed_amount),
advance_account: frm.doc.advance_account,
mode_of_payment: frm.doc.mode_of_payment,
currency: frm.doc.currency,
exchange_rate: frm.doc.exchange_rate,
},
callback: function (r) {
const doclist = frappe.model.sync(r.message);
frappe.set_route("Form", doclist[0].doctype, doclist[0].name);
},
});
},
employee: function (frm) {
if (frm.doc.employee) frm.trigger("get_employee_currency");
},
get_employee_currency: function (frm) {
frappe.db.get_value(
"Salary Structure Assignment",
{ employee: frm.doc.employee, docstatus: 1 },
"currency",
(r) => {
if (r.currency) frm.set_value("currency", r.currency);
else frm.set_value("currency", erpnext.get_currency(frm.doc.company));
frm.refresh_fields();
},
);
},
currency: function (frm) {
if (frm.doc.currency) {
var from_currency = frm.doc.currency;
var company_currency;
if (!frm.doc.company) {
company_currency = erpnext.get_currency(frappe.defaults.get_default("Company"));
} else {
company_currency = erpnext.get_currency(frm.doc.company);
}
if (from_currency != company_currency) {
frm.events.set_exchange_rate(frm, from_currency, company_currency);
} else {
frm.set_value("exchange_rate", 1.0);
frm.set_df_property("exchange_rate", "hidden", 1);
frm.set_df_property("exchange_rate", "description", "");
}
frm.refresh_fields();
}
},
set_exchange_rate: function (frm, from_currency, company_currency) {
frappe.call({
method: "erpnext.setup.utils.get_exchange_rate",
args: {
from_currency: from_currency,
to_currency: company_currency,
},
callback: function (r) {
frm.set_value("exchange_rate", flt(r.message));
frm.set_df_property("exchange_rate", "hidden", 0);
frm.set_df_property(
"exchange_rate",
"description",
"1 " + frm.doc.currency + " = [?] " + company_currency,
);
},
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_advance/employee_advance.js
|
JavaScript
|
agpl-3.0
| 5,999
|
# Copyright (c) 2017, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.query_builder.functions import Sum
from frappe.utils import flt, nowdate
import erpnext
from erpnext.accounts.doctype.journal_entry.journal_entry import get_default_bank_cash_account
import hrms
from hrms.hr.utils import validate_active_employee
class EmployeeAdvanceOverPayment(frappe.ValidationError):
pass
class EmployeeAdvance(Document):
def onload(self):
self.get("__onload").make_payment_via_journal_entry = frappe.db.get_single_value(
"Accounts Settings", "make_payment_via_journal_entry"
)
def validate(self):
validate_active_employee(self.employee)
self.validate_exchange_rate()
self.set_status()
self.set_pending_amount()
def on_cancel(self):
self.ignore_linked_doctypes = "GL Entry"
self.set_status(update=True)
def on_update(self):
self.publish_update()
def after_delete(self):
self.publish_update()
def publish_update(self):
employee_user = frappe.db.get_value("Employee", self.employee, "user_id", cache=True)
hrms.refetch_resource("hrms:employee_advance_balance", employee_user)
def validate_exchange_rate(self):
if not self.exchange_rate:
frappe.throw(_("Exchange Rate cannot be zero."))
def set_status(self, update=False):
precision = self.precision("paid_amount")
total_amount = flt(flt(self.claimed_amount) + flt(self.return_amount), precision)
status = None
if self.docstatus == 0:
status = "Draft"
elif self.docstatus == 1:
if flt(self.claimed_amount) > 0 and flt(self.claimed_amount, precision) == flt(
self.paid_amount, precision
):
status = "Claimed"
elif flt(self.return_amount) > 0 and flt(self.return_amount, precision) == flt(
self.paid_amount, precision
):
status = "Returned"
elif (
flt(self.claimed_amount) > 0
and (flt(self.return_amount) > 0)
and total_amount == flt(self.paid_amount, precision)
):
status = "Partly Claimed and Returned"
elif flt(self.paid_amount) > 0 and flt(self.advance_amount, precision) == flt(
self.paid_amount, precision
):
status = "Paid"
else:
status = "Unpaid"
elif self.docstatus == 2:
status = "Cancelled"
if update:
self.db_set("status", status)
self.publish_update()
self.notify_update()
else:
self.status = status
def set_total_advance_paid(self):
gle = frappe.qb.DocType("GL Entry")
paid_amount = (
frappe.qb.from_(gle)
.select(Sum(gle.debit).as_("paid_amount"))
.where(
(gle.against_voucher_type == "Employee Advance")
& (gle.against_voucher == self.name)
& (gle.party_type == "Employee")
& (gle.party == self.employee)
& (gle.docstatus == 1)
& (gle.is_cancelled == 0)
)
).run(as_dict=True)[0].paid_amount or 0
return_amount = (
frappe.qb.from_(gle)
.select(Sum(gle.credit).as_("return_amount"))
.where(
(gle.against_voucher_type == "Employee Advance")
& (gle.voucher_type != "Expense Claim")
& (gle.against_voucher == self.name)
& (gle.party_type == "Employee")
& (gle.party == self.employee)
& (gle.docstatus == 1)
& (gle.is_cancelled == 0)
)
).run(as_dict=True)[0].return_amount or 0
if paid_amount != 0:
paid_amount = flt(paid_amount) / flt(self.exchange_rate)
if return_amount != 0:
return_amount = flt(return_amount) / flt(self.exchange_rate)
precision = self.precision("paid_amount")
paid_amount = flt(paid_amount, precision)
if paid_amount > flt(self.advance_amount, precision):
frappe.throw(
_("Row {0}# Paid Amount cannot be greater than requested advance amount"),
EmployeeAdvanceOverPayment,
)
precision = self.precision("return_amount")
return_amount = flt(return_amount, precision)
if return_amount > 0 and return_amount > flt(self.paid_amount - self.claimed_amount, precision):
frappe.throw(_("Return amount cannot be greater than unclaimed amount"))
self.db_set("paid_amount", paid_amount)
self.db_set("return_amount", return_amount)
self.set_status(update=True)
def update_claimed_amount(self):
claimed_amount = (
frappe.db.sql(
"""
SELECT sum(ifnull(allocated_amount, 0))
FROM `tabExpense Claim Advance` eca, `tabExpense Claim` ec
WHERE
eca.employee_advance = %s
AND ec.approval_status="Approved"
AND ec.name = eca.parent
AND ec.docstatus=1
AND eca.allocated_amount > 0
""",
self.name,
)[0][0]
or 0
)
frappe.db.set_value("Employee Advance", self.name, "claimed_amount", flt(claimed_amount))
self.reload()
self.set_status(update=True)
def set_pending_amount(self):
Advance = frappe.qb.DocType("Employee Advance")
self.pending_amount = (
frappe.qb.from_(Advance)
.select(Sum(Advance.advance_amount - Advance.paid_amount))
.where(
(Advance.employee == self.employee)
& (Advance.docstatus == 1)
& (Advance.posting_date <= self.posting_date)
& (Advance.status == "Unpaid")
)
).run()[0][0] or 0.0
@frappe.whitelist()
def make_bank_entry(dt, dn):
doc = frappe.get_doc(dt, dn)
payment_account = get_default_bank_cash_account(
doc.company, account_type="Cash", mode_of_payment=doc.mode_of_payment
)
if not payment_account:
frappe.throw(_("Please set a Default Cash Account in Company defaults"))
advance_account_currency = frappe.db.get_value("Account", doc.advance_account, "account_currency")
advance_amount, advance_exchange_rate = get_advance_amount_advance_exchange_rate(
advance_account_currency, doc
)
paying_amount, paying_exchange_rate = get_paying_amount_paying_exchange_rate(payment_account, doc)
je = frappe.new_doc("Journal Entry")
je.posting_date = nowdate()
je.voucher_type = "Bank Entry"
je.company = doc.company
je.remark = "Payment against Employee Advance: " + dn + "\n" + doc.purpose
je.multi_currency = 1 if advance_account_currency != payment_account.account_currency else 0
je.append(
"accounts",
{
"account": doc.advance_account,
"account_currency": advance_account_currency,
"exchange_rate": flt(advance_exchange_rate),
"debit_in_account_currency": flt(advance_amount),
"reference_type": "Employee Advance",
"reference_name": doc.name,
"party_type": "Employee",
"cost_center": erpnext.get_default_cost_center(doc.company),
"party": doc.employee,
"is_advance": "Yes",
},
)
je.append(
"accounts",
{
"account": payment_account.account,
"cost_center": erpnext.get_default_cost_center(doc.company),
"credit_in_account_currency": flt(paying_amount),
"account_currency": payment_account.account_currency,
"account_type": payment_account.account_type,
"exchange_rate": flt(paying_exchange_rate),
},
)
return je.as_dict()
def get_advance_amount_advance_exchange_rate(advance_account_currency, doc):
if advance_account_currency != doc.currency:
advance_amount = flt(doc.advance_amount) * flt(doc.exchange_rate)
advance_exchange_rate = 1
else:
advance_amount = doc.advance_amount
advance_exchange_rate = doc.exchange_rate
return advance_amount, advance_exchange_rate
def get_paying_amount_paying_exchange_rate(payment_account, doc):
if payment_account.account_currency != doc.currency:
paying_amount = flt(doc.advance_amount) * flt(doc.exchange_rate)
paying_exchange_rate = 1
else:
paying_amount = doc.advance_amount
paying_exchange_rate = doc.exchange_rate
return paying_amount, paying_exchange_rate
@frappe.whitelist()
def create_return_through_additional_salary(doc):
import json
if isinstance(doc, str):
doc = frappe._dict(json.loads(doc))
additional_salary = frappe.new_doc("Additional Salary")
additional_salary.employee = doc.employee
additional_salary.currency = doc.currency
additional_salary.overwrite_salary_structure_amount = 0
additional_salary.amount = doc.paid_amount - doc.claimed_amount
additional_salary.company = doc.company
additional_salary.ref_doctype = doc.doctype
additional_salary.ref_docname = doc.name
return additional_salary
@frappe.whitelist()
def make_return_entry(
employee,
company,
employee_advance_name,
return_amount,
advance_account,
currency,
exchange_rate,
mode_of_payment=None,
):
bank_cash_account = get_default_bank_cash_account(
company, account_type="Cash", mode_of_payment=mode_of_payment
)
if not bank_cash_account:
frappe.throw(_("Please set a Default Cash Account in Company defaults"))
advance_account_currency = frappe.db.get_value("Account", advance_account, "account_currency")
je = frappe.new_doc("Journal Entry")
je.posting_date = nowdate()
je.voucher_type = get_voucher_type(mode_of_payment)
je.company = company
je.remark = "Return against Employee Advance: " + employee_advance_name
je.multi_currency = 1 if advance_account_currency != bank_cash_account.account_currency else 0
advance_account_amount = (
flt(return_amount)
if advance_account_currency == currency
else flt(return_amount) * flt(exchange_rate)
)
je.append(
"accounts",
{
"account": advance_account,
"credit_in_account_currency": advance_account_amount,
"account_currency": advance_account_currency,
"exchange_rate": flt(exchange_rate) if advance_account_currency == currency else 1,
"reference_type": "Employee Advance",
"reference_name": employee_advance_name,
"party_type": "Employee",
"party": employee,
"is_advance": "Yes",
"cost_center": erpnext.get_default_cost_center(company),
},
)
bank_amount = (
flt(return_amount)
if bank_cash_account.account_currency == currency
else flt(return_amount) * flt(exchange_rate)
)
je.append(
"accounts",
{
"account": bank_cash_account.account,
"debit_in_account_currency": bank_amount,
"account_currency": bank_cash_account.account_currency,
"account_type": bank_cash_account.account_type,
"exchange_rate": flt(exchange_rate) if bank_cash_account.account_currency == currency else 1,
"cost_center": erpnext.get_default_cost_center(company),
},
)
return je.as_dict()
def get_voucher_type(mode_of_payment=None):
voucher_type = "Cash Entry"
if mode_of_payment:
mode_of_payment_type = frappe.get_cached_value("Mode of Payment", mode_of_payment, "type")
if mode_of_payment_type == "Bank":
voucher_type = "Bank Entry"
return voucher_type
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_advance/employee_advance.py
|
Python
|
agpl-3.0
| 10,360
|
def get_data():
return {
"fieldname": "employee_advance",
"non_standard_fieldnames": {
"Payment Entry": "reference_name",
"Journal Entry": "reference_name",
},
"transactions": [{"items": ["Expense Claim"]}, {"items": ["Payment Entry", "Journal Entry"]}],
}
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_advance/employee_advance_dashboard.py
|
Python
|
agpl-3.0
| 273
|
.top-toolbar {
padding-bottom: 30px;
margin-left: -17px;
}
.bottom-toolbar {
margin-left: -17px;
margin-top: 20px;
}
.btn {
margin-right: 5px;
}
.marked-employee-label {
font-weight: normal;
}
.checkbox {
margin-top: -3px;
}
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_attendance_tool/employee_attendance_tool.css
|
CSS
|
agpl-3.0
| 236
|
frappe.ui.form.on("Employee Attendance Tool", {
refresh(frm) {
frm.trigger("reset_attendance_fields");
frm.trigger("load_employees");
frm.trigger("set_primary_action");
},
onload(frm) {
frm.set_value("date", frappe.datetime.get_today());
},
date(frm) {
frm.trigger("load_employees");
},
department(frm) {
frm.trigger("load_employees");
},
branch(frm) {
frm.trigger("load_employees");
},
company(frm) {
frm.trigger("load_employees");
},
status(frm) {
frm.trigger("set_primary_action");
},
reset_attendance_fields(frm) {
frm.set_value("status", "");
frm.set_value("shift", "");
frm.set_value("late_entry", 0);
frm.set_value("early_exit", 0);
},
load_employees(frm) {
if (!frm.doc.date) return;
frappe
.call({
method: "hrms.hr.doctype.employee_attendance_tool.employee_attendance_tool.get_employees",
args: {
date: frm.doc.date,
department: frm.doc.department,
branch: frm.doc.branch,
company: frm.doc.company,
},
})
.then((r) => {
frm.employees = r.message["unmarked"];
if (r.message["unmarked"].length > 0) {
unhide_field("unmarked_attendance_section");
unhide_field("attendance_details_section");
frm.events.show_unmarked_employees(frm, r.message["unmarked"]);
} else {
hide_field("unmarked_attendance_section");
hide_field("attendance_details_section");
}
if (r.message["marked"].length > 0) {
unhide_field("marked_attendance_html");
frm.events.show_marked_employees(frm, r.message["marked"]);
} else {
hide_field("marked_attendance_html");
}
});
},
show_unmarked_employees(frm, unmarked_employees) {
const $wrapper = frm.get_field("employees_html").$wrapper;
$wrapper.empty();
const employee_wrapper = $(`<div class="employee_wrapper">`).appendTo($wrapper);
frm.employees_multicheck = frappe.ui.form.make_control({
parent: employee_wrapper,
df: {
fieldname: "employees_multicheck",
fieldtype: "MultiCheck",
select_all: true,
columns: 4,
get_data: () => {
return unmarked_employees.map((employee) => {
return {
label: `${employee.employee} : ${employee.employee_name}`,
value: employee.employee,
checked: 0,
};
});
},
},
render_input: true,
});
frm.employees_multicheck.refresh_input();
},
show_marked_employees(frm, marked_employees) {
const $wrapper = frm.get_field("marked_attendance_html").$wrapper;
const summary_wrapper = $(`<div class="summary_wrapper">`).appendTo($wrapper);
const data = marked_employees.map((entry) => {
return [`${entry.employee} : ${entry.employee_name}`, entry.status];
});
frm.events.render_datatable(frm, data, summary_wrapper);
},
render_datatable(frm, data, summary_wrapper) {
const columns = frm.events.get_columns_for_marked_attendance_table(frm);
if (!frm.marked_emp_datatable) {
const datatable_options = {
columns: columns,
data: data,
dynamicRowHeight: true,
inlineFilters: true,
layout: "fluid",
cellHeight: 35,
noDataMessage: __("No Data"),
disableReorderColumn: true,
};
frm.marked_emp_datatable = new frappe.DataTable(
summary_wrapper.get(0),
datatable_options,
);
} else {
frm.marked_emp_datatable.refresh(data, columns);
}
},
get_columns_for_marked_attendance_table(frm) {
return [
{
name: "employee",
id: "employee",
content: __("Employee"),
editable: false,
sortable: false,
focusable: false,
dropdown: false,
align: "left",
width: 350,
},
{
name: "status",
id: "status",
content: __("Status"),
editable: false,
sortable: false,
focusable: false,
dropdown: false,
align: "left",
width: 150,
format: (value) => {
if (value == "Present" || value == "Work From Home")
return `<span style="color:green">${__(value)}</span>`;
else if (value == "Absent")
return `<span style="color:red">${__(value)}</span>`;
else if (value == "Half Day")
return `<span style="color:orange">${__(value)}</span>`;
else if (value == "On Leave")
return `<span style="color:#318AD8">${__(value)}</span>`;
},
},
];
},
set_primary_action(frm) {
frm.disable_save();
frm.page.set_primary_action(__("Mark Attendance"), () => {
if (frm.employees.length === 0) {
frappe.msgprint({
message: __(
"Attendance for all the employees under this criteria has been marked already.",
),
title: __("Attendance Marked"),
indicator: "green",
});
return;
}
if (frm.employees_multicheck.get_checked_options().length === 0) {
frappe.throw({
message: __("Please select the employees you want to mark attendance for."),
title: __("Mandatory"),
});
}
if (!frm.doc.status) {
frappe.throw({
message: __("Please select the attendance status."),
title: __("Mandatory"),
});
}
frm.trigger("mark_attendance");
});
},
mark_attendance(frm) {
const marked_employees = frm.employees_multicheck.get_checked_options();
frappe
.call({
method: "hrms.hr.doctype.employee_attendance_tool.employee_attendance_tool.mark_employee_attendance",
args: {
employee_list: marked_employees,
status: frm.doc.status,
date: frm.doc.date,
late_entry: frm.doc.late_entry,
early_exit: frm.doc.early_exit,
shift: frm.doc.shift,
},
freeze: true,
freeze_message: __("Marking Attendance"),
})
.then((r) => {
if (!r.exc) {
frappe.show_alert({
message: __("Attendance marked successfully"),
indicator: "green",
});
frm.refresh();
}
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_attendance_tool/employee_attendance_tool.js
|
JavaScript
|
agpl-3.0
| 5,708
|
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import datetime
import json
import frappe
from frappe.model.document import Document
from frappe.utils import getdate
class EmployeeAttendanceTool(Document):
pass
@frappe.whitelist()
def get_employees(
date: str | datetime.date,
department: str | None = None,
branch: str | None = None,
company: str | None = None,
) -> dict[str, list]:
filters = {"status": "Active", "date_of_joining": ["<=", date]}
for field, value in {"department": department, "branch": branch, "company": company}.items():
if value:
filters[field] = value
employee_list = frappe.get_list(
"Employee", fields=["employee", "employee_name"], filters=filters, order_by="employee_name"
)
attendance_list = frappe.get_list(
"Attendance",
fields=["employee", "employee_name", "status"],
filters={
"attendance_date": date,
"docstatus": 1,
},
order_by="employee_name",
)
unmarked_attendance = _get_unmarked_attendance(employee_list, attendance_list)
return {"marked": attendance_list, "unmarked": unmarked_attendance}
def _get_unmarked_attendance(employee_list: list[dict], attendance_list: list[dict]) -> list[dict]:
marked_employees = [entry.employee for entry in attendance_list]
unmarked_attendance = []
for entry in employee_list:
if entry.employee not in marked_employees:
unmarked_attendance.append(entry)
return unmarked_attendance
@frappe.whitelist()
def mark_employee_attendance(
employee_list: list | str,
status: str,
date: str | datetime.date,
leave_type: str | None = None,
company: str | None = None,
late_entry: int | None = None,
early_exit: int | None = None,
shift: str | None = None,
) -> None:
if isinstance(employee_list, str):
employee_list = json.loads(employee_list)
for employee in employee_list:
leave_type = None
if status == "On Leave" and leave_type:
leave_type = leave_type
attendance = frappe.get_doc(
dict(
doctype="Attendance",
employee=employee,
attendance_date=getdate(date),
status=status,
leave_type=leave_type,
late_entry=late_entry,
early_exit=early_exit,
shift=shift,
)
)
attendance.insert()
attendance.submit()
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_attendance_tool/employee_attendance_tool.py
|
Python
|
agpl-3.0
| 2,264
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class EmployeeBoardingActivity(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_boarding_activity/employee_boarding_activity.py
|
Python
|
agpl-3.0
| 214
|
// Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Checkin", {
refresh: async (frm) => {
if (!frm.doc.__islocal) frm.trigger("add_fetch_shift_button");
const allow_geolocation_tracking = await frappe.db.get_single_value(
"HR Settings",
"allow_geolocation_tracking",
);
if (!allow_geolocation_tracking) {
hide_field(["fetch_geolocation", "latitude", "longitude", "geolocation"]);
return;
}
},
add_fetch_shift_button(frm) {
if (frm.doc.attendace) return;
frm.add_custom_button(__("Fetch Shift"), function () {
const previous_shift = frm.doc.shift;
frappe.call({
method: "fetch_shift",
doc: frm.doc,
freeze: true,
freeze_message: __("Fetching Shift"),
callback: function () {
if (previous_shift === frm.doc.shift) return;
frm.dirty();
frm.save();
frappe.show_alert({
message: __("Shift has been successfully updated to {0}.", [
frm.doc.shift,
]),
indicator: "green",
});
},
});
});
},
fetch_geolocation: async (frm) => {
if (!navigator.geolocation) {
frappe.msgprint({
message: __("Geolocation is not supported by your current browser"),
title: __("Geolocation Error"),
indicator: "red",
});
hide_field(["geolocation"]);
return;
}
frappe.dom.freeze(__("Fetching your geolocation") + "...");
navigator.geolocation.getCurrentPosition(
async (position) => {
frm.set_value("latitude", position.coords.latitude);
frm.set_value("longitude", position.coords.longitude);
await frm.call("set_geolocation_from_coordinates");
frm.dirty();
frappe.dom.unfreeze();
},
(error) => {
frappe.dom.unfreeze();
let msg = __("Unable to retrieve your location") + "<br><br>";
if (error) {
msg += __("ERROR({0}): {1}", [error.code, error.message]);
}
frappe.msgprint({
message: msg,
title: __("Geolocation Error"),
indicator: "red",
});
},
);
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_checkin/employee_checkin.js
|
JavaScript
|
agpl-3.0
| 2,057
|
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.utils import cint, get_datetime
from hrms.hr.doctype.shift_assignment.shift_assignment import (
get_actual_start_end_datetime_of_shift,
)
from hrms.hr.utils import validate_active_employee
class EmployeeCheckin(Document):
def validate(self):
validate_active_employee(self.employee)
self.validate_duplicate_log()
self.fetch_shift()
self.set_geolocation_from_coordinates()
def validate_duplicate_log(self):
doc = frappe.db.exists(
"Employee Checkin",
{
"employee": self.employee,
"time": self.time,
"name": ("!=", self.name),
"log_type": self.log_type,
},
)
if doc:
doc_link = frappe.get_desk_link("Employee Checkin", doc)
frappe.throw(
_("This employee already has a log with the same timestamp.{0}").format("<Br>" + doc_link)
)
@frappe.whitelist()
def fetch_shift(self):
if not (
shift_actual_timings := get_actual_start_end_datetime_of_shift(
self.employee, get_datetime(self.time), True
)
):
self.shift = None
return
if (
shift_actual_timings.shift_type.determine_check_in_and_check_out
== "Strictly based on Log Type in Employee Checkin"
and not self.log_type
and not self.skip_auto_attendance
):
frappe.throw(
_("Log Type is required for check-ins falling in the shift: {0}.").format(
shift_actual_timings.shift_type.name
)
)
if not self.attendance:
self.shift = shift_actual_timings.shift_type.name
self.shift_actual_start = shift_actual_timings.actual_start
self.shift_actual_end = shift_actual_timings.actual_end
self.shift_start = shift_actual_timings.start_datetime
self.shift_end = shift_actual_timings.end_datetime
@frappe.whitelist()
def set_geolocation_from_coordinates(self):
if not frappe.db.get_single_value("HR Settings", "allow_geolocation_tracking"):
return
if not (self.latitude and self.longitude):
return
self.geolocation = frappe.json.dumps(
{
"type": "FeatureCollection",
"features": [
{
"type": "Feature",
"properties": {},
# geojson needs coordinates in reverse order: long, lat instead of lat, long
"geometry": {"type": "Point", "coordinates": [self.longitude, self.latitude]},
}
],
}
)
@frappe.whitelist()
def add_log_based_on_employee_field(
employee_field_value,
timestamp,
device_id=None,
log_type=None,
skip_auto_attendance=0,
employee_fieldname="attendance_device_id",
):
"""Finds the relevant Employee using the employee field value and creates a Employee Checkin.
:param employee_field_value: The value to look for in employee field.
:param timestamp: The timestamp of the Log. Currently expected in the following format as string: '2019-05-08 10:48:08.000000'
:param device_id: (optional)Location / Device ID. A short string is expected.
:param log_type: (optional)Direction of the Punch if available (IN/OUT).
:param skip_auto_attendance: (optional)Skip auto attendance field will be set for this log(0/1).
:param employee_fieldname: (Default: attendance_device_id)Name of the field in Employee DocType based on which employee lookup will happen.
"""
if not employee_field_value or not timestamp:
frappe.throw(_("'employee_field_value' and 'timestamp' are required."))
employee = frappe.db.get_values(
"Employee",
{employee_fieldname: employee_field_value},
["name", "employee_name", employee_fieldname],
as_dict=True,
)
if employee:
employee = employee[0]
else:
frappe.throw(
_("No Employee found for the given employee field value. '{}': {}").format(
employee_fieldname, employee_field_value
)
)
doc = frappe.new_doc("Employee Checkin")
doc.employee = employee.name
doc.employee_name = employee.employee_name
doc.time = timestamp
doc.device_id = device_id
doc.log_type = log_type
if cint(skip_auto_attendance) == 1:
doc.skip_auto_attendance = "1"
doc.insert()
return doc
@frappe.whitelist()
def bulk_fetch_shift(checkins: list[str] | str) -> None:
if isinstance(checkins, str):
checkins = frappe.json.loads(checkins)
for d in checkins:
doc = frappe.get_doc("Employee Checkin", d)
doc.fetch_shift()
doc.flags.ignore_validate = True
doc.save()
def mark_attendance_and_link_log(
logs,
attendance_status,
attendance_date,
working_hours=None,
late_entry=False,
early_exit=False,
in_time=None,
out_time=None,
shift=None,
):
"""Creates an attendance and links the attendance to the Employee Checkin.
Note: If attendance is already present for the given date, the logs are marked as skipped and no exception is thrown.
:param logs: The List of 'Employee Checkin'.
:param attendance_status: Attendance status to be marked. One of: (Present, Absent, Half Day, Skip). Note: 'On Leave' is not supported by this function.
:param attendance_date: Date of the attendance to be created.
:param working_hours: (optional)Number of working hours for the given date.
"""
log_names = [x.name for x in logs]
employee = logs[0].employee
if attendance_status == "Skip":
skip_attendance_in_checkins(log_names)
return None
elif attendance_status in ("Present", "Absent", "Half Day"):
try:
frappe.db.savepoint("attendance_creation")
attendance = frappe.new_doc("Attendance")
attendance.update(
{
"doctype": "Attendance",
"employee": employee,
"attendance_date": attendance_date,
"status": attendance_status,
"working_hours": working_hours,
"shift": shift,
"late_entry": late_entry,
"early_exit": early_exit,
"in_time": in_time,
"out_time": out_time,
}
).submit()
if attendance_status == "Absent":
attendance.add_comment(
text=_("Employee was marked Absent for not meeting the working hours threshold.")
)
update_attendance_in_checkins(log_names, attendance.name)
return attendance
except frappe.ValidationError as e:
handle_attendance_exception(log_names, e)
else:
frappe.throw(_("{} is an invalid Attendance Status.").format(attendance_status))
def calculate_working_hours(logs, check_in_out_type, working_hours_calc_type):
"""Given a set of logs in chronological order calculates the total working hours based on the parameters.
Zero is returned for all invalid cases.
:param logs: The List of 'Employee Checkin'.
:param check_in_out_type: One of: 'Alternating entries as IN and OUT during the same shift', 'Strictly based on Log Type in Employee Checkin'
:param working_hours_calc_type: One of: 'First Check-in and Last Check-out', 'Every Valid Check-in and Check-out'
"""
total_hours = 0
in_time = out_time = None
if check_in_out_type == "Alternating entries as IN and OUT during the same shift":
in_time = logs[0].time
if len(logs) >= 2:
out_time = logs[-1].time
if working_hours_calc_type == "First Check-in and Last Check-out":
# assumption in this case: First log always taken as IN, Last log always taken as OUT
total_hours = time_diff_in_hours(in_time, logs[-1].time)
elif working_hours_calc_type == "Every Valid Check-in and Check-out":
logs = logs[:]
while len(logs) >= 2:
total_hours += time_diff_in_hours(logs[0].time, logs[1].time)
del logs[:2]
elif check_in_out_type == "Strictly based on Log Type in Employee Checkin":
if working_hours_calc_type == "First Check-in and Last Check-out":
first_in_log_index = find_index_in_dict(logs, "log_type", "IN")
first_in_log = logs[first_in_log_index] if first_in_log_index or first_in_log_index == 0 else None
last_out_log_index = find_index_in_dict(reversed(logs), "log_type", "OUT")
last_out_log = (
logs[len(logs) - 1 - last_out_log_index]
if last_out_log_index or last_out_log_index == 0
else None
)
if first_in_log and last_out_log:
in_time, out_time = first_in_log.time, last_out_log.time
total_hours = time_diff_in_hours(in_time, out_time)
elif working_hours_calc_type == "Every Valid Check-in and Check-out":
in_log = out_log = None
for log in logs:
if in_log and out_log:
if not in_time:
in_time = in_log.time
out_time = out_log.time
total_hours += time_diff_in_hours(in_log.time, out_log.time)
in_log = out_log = None
if not in_log:
in_log = log if log.log_type == "IN" else None
if in_log and not in_time:
in_time = in_log.time
elif not out_log:
out_log = log if log.log_type == "OUT" else None
if in_log and out_log:
out_time = out_log.time
total_hours += time_diff_in_hours(in_log.time, out_log.time)
return total_hours, in_time, out_time
def time_diff_in_hours(start, end):
return round(float((end - start).total_seconds()) / 3600, 2)
def find_index_in_dict(dict_list, key, value):
return next((index for (index, d) in enumerate(dict_list) if d[key] == value), None)
def handle_attendance_exception(log_names: list, error_message: str):
frappe.db.rollback(save_point="attendance_creation")
frappe.clear_messages()
skip_attendance_in_checkins(log_names)
add_comment_in_checkins(log_names, error_message)
def add_comment_in_checkins(log_names: list, error_message: str):
text = "{prefix}<br>{error_message}".format(
prefix=frappe.bold(_("Reason for skipping auto attendance:")), error_message=error_message
)
for name in log_names:
frappe.get_doc(
{
"doctype": "Comment",
"comment_type": "Comment",
"reference_doctype": "Employee Checkin",
"reference_name": name,
"content": text,
}
).insert(ignore_permissions=True)
def skip_attendance_in_checkins(log_names: list):
EmployeeCheckin = frappe.qb.DocType("Employee Checkin")
(
frappe.qb.update(EmployeeCheckin)
.set("skip_auto_attendance", 1)
.where(EmployeeCheckin.name.isin(log_names))
).run()
def update_attendance_in_checkins(log_names: list, attendance_id: str):
EmployeeCheckin = frappe.qb.DocType("Employee Checkin")
(
frappe.qb.update(EmployeeCheckin)
.set("attendance", attendance_id)
.where(EmployeeCheckin.name.isin(log_names))
).run()
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_checkin/employee_checkin.py
|
Python
|
agpl-3.0
| 10,142
|
frappe.listview_settings["Employee Checkin"] = {
onload: function (listview) {
listview.page.add_action_item(__("Fetch Shifts"), () => {
const checkins = listview.get_checked_items().map((checkin) => checkin.name);
frappe.call({
method: "hrms.hr.doctype.employee_checkin.employee_checkin.bulk_fetch_shift",
freeze: true,
args: {
checkins,
},
});
});
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_checkin/employee_checkin_list.js
|
JavaScript
|
agpl-3.0
| 392
|
// Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
// frappe.ui.form.on("Employee Feedback Criteria", {
// refresh(frm) {
// },
// });
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_feedback_criteria/employee_feedback_criteria.js
|
JavaScript
|
agpl-3.0
| 209
|
# Copyright (c) 2023, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class EmployeeFeedbackCriteria(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_feedback_criteria/employee_feedback_criteria.py
|
Python
|
agpl-3.0
| 229
|
# Copyright (c) 2022, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
# import frappe
from frappe.model.document import Document
class EmployeeFeedbackRating(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_feedback_rating/employee_feedback_rating.py
|
Python
|
agpl-3.0
| 227
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Grade", {
refresh: function (frm) {},
setup: function (frm) {
frm.set_query("default_salary_structure", function () {
return {
filters: {
docstatus: 1,
is_active: "Yes",
},
};
});
frm.set_query("default_leave_policy", function () {
return {
filters: {
docstatus: 1,
},
};
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_grade/employee_grade.js
|
JavaScript
|
agpl-3.0
| 488
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class EmployeeGrade(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_grade/employee_grade.py
|
Python
|
agpl-3.0
| 203
|
def get_data():
return {
"transactions": [
{
"items": ["Employee", "Leave Period"],
},
{"items": ["Employee Onboarding Template", "Employee Separation Template"]},
]
}
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_grade/employee_grade_dashboard.py
|
Python
|
agpl-3.0
| 187
|
// Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Grievance", {
setup: function (frm) {
frm.set_query("grievance_against_party", function () {
return {
filters: {
name: [
"in",
["Company", "Department", "Employee Group", "Employee Grade", "Employee"],
],
},
};
});
frm.set_query("associated_document_type", function () {
let ignore_modules = [
"Setup",
"Core",
"Integrations",
"Automation",
"Website",
"Utilities",
"Event Streaming",
"Social",
"Chat",
"Data Migration",
"Printing",
"Desk",
"Custom",
];
return {
filters: {
istable: 0,
issingle: 0,
module: ["Not In", ignore_modules],
},
};
});
},
grievance_against_party: function (frm) {
let filters = {};
if (frm.doc.grievance_against_party == "Employee" && frm.doc.raised_by) {
filters.name = ["!=", frm.doc.raised_by];
}
frm.set_query("grievance_against", function () {
return {
filters: filters,
};
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_grievance/employee_grievance.js
|
JavaScript
|
agpl-3.0
| 1,124
|
# Copyright (c) 2021, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import frappe
from frappe import _, bold
from frappe.model.document import Document
class EmployeeGrievance(Document):
def on_submit(self):
if self.status not in ["Invalid", "Resolved"]:
frappe.throw(
_("Only Employee Grievance with status {0} or {1} can be submitted").format(
bold("Invalid"), bold("Resolved")
)
)
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_grievance/employee_grievance.py
|
Python
|
agpl-3.0
| 460
|
frappe.listview_settings["Employee Grievance"] = {
has_indicator_for_draft: 1,
get_indicator: function (doc) {
var colors = {
Open: "red",
Investigated: "orange",
Resolved: "green",
Invalid: "grey",
};
return [__(doc.status), colors[doc.status], "status,=," + doc.status];
},
};
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_grievance/employee_grievance_list.js
|
JavaScript
|
agpl-3.0
| 300
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Health Insurance", {
refresh: function (frm) {},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_health_insurance/employee_health_insurance.js
|
JavaScript
|
agpl-3.0
| 204
|
# Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from frappe.model.document import Document
class EmployeeHealthInsurance(Document):
pass
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_health_insurance/employee_health_insurance.py
|
Python
|
agpl-3.0
| 213
|
// Copyright (c) 2018, Frappe Technologies Pvt. Ltd. and contributors
// For license information, please see license.txt
frappe.ui.form.on("Employee Onboarding", {
setup: function (frm) {
frm.set_query("job_applicant", function () {
return {
filters: {
status: "Accepted",
},
};
});
frm.set_query("job_offer", function () {
return {
filters: {
job_applicant: frm.doc.job_applicant,
docstatus: 1,
},
};
});
},
refresh: function (frm) {
if (frm.doc.employee) {
frm.add_custom_button(
__("Employee"),
function () {
frappe.set_route("Form", "Employee", frm.doc.employee);
},
__("View"),
);
}
if (frm.doc.project) {
frm.add_custom_button(
__("Project"),
function () {
frappe.set_route("Form", "Project", frm.doc.project);
},
__("View"),
);
frm.add_custom_button(
__("Task"),
function () {
frappe.set_route("List", "Task", { project: frm.doc.project });
},
__("View"),
);
}
if (!frm.doc.employee && frm.doc.docstatus === 1) {
frm.add_custom_button(
__("Employee"),
function () {
frappe.model.open_mapped_doc({
method: "hrms.hr.doctype.employee_onboarding.employee_onboarding.make_employee",
frm: frm,
});
},
__("Create"),
);
frm.page.set_inner_btn_group_as_primary(__("Create"));
}
if (
frm.doc.docstatus === 1 &&
(frm.doc.boarding_status === "Pending" || frm.doc.boarding_status === "In Process")
) {
frm.add_custom_button(__("Mark as Completed"), function () {
frm.trigger("mark_as_completed");
});
}
},
employee_onboarding_template: function (frm) {
frm.set_value("activities", "");
if (frm.doc.employee_onboarding_template) {
frappe.call({
method: "hrms.controllers.employee_boarding_controller.get_onboarding_details",
args: {
parent: frm.doc.employee_onboarding_template,
parenttype: "Employee Onboarding Template",
},
callback: function (r) {
if (r.message) {
r.message.forEach((d) => {
frm.add_child("activities", d);
});
refresh_field("activities");
}
},
});
}
},
job_applicant: function (frm) {
if (frm.doc.job_applicant) {
frappe.db.get_value(
"Employee",
{ job_applicant: frm.doc.job_applicant },
"name",
(r) => {
if (r.name) {
frm.set_value("employee", r.name);
} else {
frm.set_value("employee", "");
}
},
);
} else {
frm.set_value("employee", "");
}
},
mark_as_completed(frm) {
frm.call({
method: "mark_onboarding_as_completed",
doc: frm.doc,
freeze: true,
freeze_message: __("Completing onboarding"),
}).then((r) => {
frm.refresh();
});
},
});
|
2302_79757062/hrms
|
hrms/hr/doctype/employee_onboarding/employee_onboarding.js
|
JavaScript
|
agpl-3.0
| 2,743
|