AccountController

Imports System.Globalization
Imports System.Security.Claims
Imports System.Threading.Tasks
Imports Microsoft.AspNet.Identity
Imports Microsoft.AspNet.Identity.Owin
Imports Microsoft.AspNet.Identity.EntityFramework
Imports Microsoft.Owin.Security
Imports Owin
Imports EmployeePerformanceCore
Imports System.IO
Imports System.Net.Mail
Imports System.Net
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Web.Script.Serialization

<Authorize>
Public Class AccountController
    Inherits Controllers.BaseController

    Private ius As IUserSession
    Private iuss As IUserService
    Private idb As IDataContext
    Private istorages As IStorageService
    Private ims As IMailService

    Private usermanager As UserManager(Of User, Integer)

    Public Sub New(_ius As IUserSession, _iuss As IUserService, _idb As IDataContext, _istorages As IStorageService, _ims As IMailService)

        Dim _userstore As New UserStore(Of User, UserIdentityRole, Integer, UserLogin, UserRole, UserClaim)(_idb)
        Dim _usermanager As New UserManager(Of User, Integer)(_userstore)

        ius = _ius
        iuss = _iuss
        idb = _idb
        istorages = _istorages
        usermanager = _usermanager
        ims = _ims

    End Sub

    Public Function Unauthorized(Optional returnurl As String = "") As ActionResult
        Dim r As New Result
        r.Errors.Add("You're not authorized to view the following page : " & returnurl)
        Dim user As User = usermanager.FindByEmail(ius.currentusername)

        MHelper.showresult(r, TempData)
        Return View(user.staff)
    End Function

    '
    ' GET: /Account/Login
    <OutputCache(NoStore:=True, Duration:=0)>
    <AllowAnonymous>
    Public Function Login(returnUrl As String) As ActionResult
        Dim model As New LoginViewModel

        If Not Request.Cookies("RememberMe") Is Nothing Then
            model.UserName = Request.Cookies("RememberMe").Item("UNAME")
            model.Password = Request.Cookies("RememberMe").Item("UPASS")
            model.RememberMe = Convert.ToBoolean(Request.Cookies("RememberMe").Item("REMEMBER"))
        End If

        If Request.IsAuthenticated Then
            If Not ius Is Nothing Then
                If ius.currentuserid > 0 And ius.currentcompanyid > 0 Then
                    Return RedirectToAction("UnAuthorized", New With {.returnurl = returnUrl})
                End If
            End If
        End If

        ViewBag.returnurl = returnUrl
        Return View(model)
    End Function

    '
    ' POST: /Account/Login
    <OutputCache(NoStore:=True, Duration:=0)>
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Async Function Login(model As LoginViewModel, returnUrl As String) As Task(Of ActionResult)
        Dim r As New Result

        If model.RememberMe Then
            If (Request.Browser.Cookies) Then
                If (Request.Cookies("RememberMe") Is Nothing) Then
                    Response.Cookies("Remember").Expires = DateTime.Now.AddDays(30)
                End If

                Response.Cookies("RememberMe").Item("Username") = model.UserName
                Response.Cookies("RememberMe").Item("Password") = model.Password
                Response.Cookies("RememberMe").Item("REMEMBER") = model.RememberMe
            End If

        Else
            Response.Cookies("RememberMe").Item("Username") = ""
            Response.Cookies("RememberMe").Item("Password") = ""
            Response.Cookies("RememberMe").Item("REMEMBER") = model.RememberMe
        End If

        Dim appUser As User = Await usermanager.FindAsync(model.UserName, model.Password)
        If appUser IsNot Nothing Then

            If appUser.isActive = UserStatus.Inactive Then
                r.Errors.Add("This user have been deactivated.")
                MHelper.showresult(r, TempData)
                Return RedirectToAction("login")
            End If

            Await SignInAsync(appUser, model.RememberMe)

            appUser.logoffredirecturl = Nothing
            idb.updatesave(appUser)

            MHelper.showresult(r, TempData, "Hey, " & appUser.staff.name & "! Welcome back!")
            Return RedirectToLocal(returnUrl)
        Else
            r.Errors.Add("Username or password not found.")
        End If

        MHelper.showresult(r, TempData)
        Return RedirectToAction("login")
    End Function

    Private Async Function SignInAsync(user As User, isPersistent As Boolean) As Task

        AuthenticationManager.SignOut(Microsoft.AspNet.Identity.DefaultAuthenticationTypes.ExternalCookie)

        Dim identity = Await usermanager.CreateIdentityAsync(user, Microsoft.AspNet.Identity.DefaultAuthenticationTypes.ApplicationCookie)
        identity.AddClaim(New Claim("staffid", user.staffid))
        identity.AddClaim(New Claim("companyid", user.companyid))
        identity.AddClaim(New Claim("companyname", user.company.name))

        Dim isSupervisor As Boolean = False
        If idb.Staffs.Where(Function(a) a.isActive And a.companyid = user.companyid And a.staffsupervisorid = user.staffid).Count Then
            isSupervisor = True
        End If
        identity.AddClaim(New Claim("isSupervisor", isSupervisor))

        If Not user.company.logo Is Nothing Then
            identity.AddClaim(New Claim("companylogo", user.company.logo))
        Else
            identity.AddClaim(New Claim("companylogo", Url.Content("~/content/themes/assets/global/img/no-camera.png")))
        End If

        'permission
        For Each permission In user.EPUserRoles
            If Not identity.HasClaim("permissions", permission.role.EnumRole) Then
                identity.AddClaim(New Claim("permissions", permission.role.EnumRole))
            End If
        Next

        AuthenticationManager.SignIn(New AuthenticationProperties() With {.isPersistent = isPersistent}, identity)
    End Function


    Private Async Function ExternalSignInAsync(user As User) As Task
        AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie)

        Dim id = New ClaimsIdentity(DefaultAuthenticationTypes.ApplicationCookie, ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType)
        id.AddClaim(New Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "ASP.NET Identity", ClaimValueTypes.String))
        id.AddClaim(New Claim(ClaimsIdentity.DefaultNameClaimType, user.UserName, ClaimValueTypes.String))
        id.AddClaim(New Claim(ClaimTypes.NameIdentifier, user.Id, ClaimValueTypes.String))

        id.AddClaim(New Claim("staffid", user.staffid))
        id.AddClaim(New Claim("companyid", user.companyid))
        id.AddClaim(New Claim("companyname", user.company.name))
        If Not user.company.logo Is Nothing Then
            id.AddClaim(New Claim("companylogo", user.company.logo))
        Else
            id.AddClaim(New Claim("companylogo", Url.Content("~/content/themes/assets/global/img/no-camera.png")))
        End If

        'permission
        For Each permission In user.EPUserRoles
            If Not id.HasClaim("permissions", permission.role.EnumRole) Then
                id.AddClaim(New Claim("permissions", permission.role.EnumRole))
            End If
        Next

        AuthenticationManager.SignIn(New AuthenticationProperties() With {.IsPersistent = False}, id)
    End Function

    Public Function LogOff(logoffredirecturl As String) As ActionResult
        AuthenticationManager.SignOut()

        Dim r As New Result
        MHelper.showresult(r, TempData, "You have successfully log out!")

        If Not String.IsNullOrEmpty(logoffredirecturl) Then
            Return Redirect(logoffredirecturl)
        End If

        Return RedirectToAction("Login")
    End Function

    '
    ' GET: /Account/Register
    <AllowAnonymous>
    Public Function Register() As ActionResult

        Return View()
    End Function

    '
    ' POST: /Account/Register
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Async Function Register(model As RegisterViewModel) As Task(Of ActionResult)
        Dim r As New Result

        Dim checkemail As User = idb.Users.Where(Function(a) a.Email.Trim.ToLower = model.Email.Trim.ToLower).FirstOrDefault
        If Not checkemail Is Nothing Then
            r.Errors.Add("The email address have been used. Please use another email.")
            MHelper.showresult(r, TempData)
            Return RedirectToAction("Login")
        End If

        If isEmailAddressValid(model.Email) Then
            r = Await iuss.RegisterCompanyAsync(model.CompanyName, model.Email, model.StaffName, model.Password, model.ConfirmPassword)

            If r.isSuccess Then
                Dim user As User = usermanager.FindByEmail(model.Email)

                Dim userrole As New EPUserRole
                userrole.userid = user.Id
                userrole.roleid = idb.EPRoles.Where(Function(a) a.EnumRole = EnumRole.Admin).FirstOrDefault.id
                idb.EPUserRoles.Add(userrole)

                r = idb.save(ius.currentuserid, ius.currentcompanyid)

                MHelper.showresult(r, TempData, "Registration completed. You may now log in.")
                Return RedirectToAction("", "")
            Else
                MHelper.showresult(r, TempData)
                Return View(model)
            End If
        Else
            r.Errors.Add("Please provide a correct email address!")
            MHelper.showresult(r, TempData)
            Return View(model)
        End If
    End Function

    Function isEmailAddressValid(ByVal emailAddress As String) As Boolean
        Dim regExPattern As String = "\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z"

        If Regex.IsMatch(emailAddress, regExPattern) Then
            Return True
        Else
            Return False
        End If
    End Function
    '
    ' GET: /Account/ConfirmEmail
    <AllowAnonymous>
    Public Async Function ConfirmEmail(userId As String, code As String) As Task(Of ActionResult)
        If userId Is Nothing OrElse code Is Nothing Then
            Return View("Error")
        End If
        Dim result = Await usermanager.ConfirmEmailAsync(userId, code)
        Return View(If(result.Succeeded, "ConfirmEmail", "Error"))
    End Function

    <HttpPost()>
    <AllowAnonymous()>
    Public Async Function RecoverPassword(ByVal model As ResetPasswordViewModel) As Threading.Tasks.Task(Of ActionResult)

        ViewBag.error = "0"
        Dim r As New Result

        r = iuss.FindUserByUsername(model.Email)
        If Not r.isSuccess Then
            MHelper.showresult(r, TempData)
            ViewBag.error = r.Errors.FirstOrDefault
            Return RedirectToAction("login")
        End If

        Dim rand As New Random
        Dim newpassword As String = rand.Next(100000, 999999)
        Dim successchangepassword As Boolean = False

        r = Await iuss.ResetPasswordAsync(model.Email, newpassword)
        If Not r.isSuccess Then
            MHelper.showresult(r, TempData)
            ViewBag.error = r.Errors.FirstOrDefault
            Return View()
        Else
            Dim user = Await usermanager.FindByNameAsync(model.Email)
            Dim websiteurl As String = ConfigurationManager.AppSettings("websiteurl")

            Dim email As New Email
            email.to = model.Email
            email.subject = "You have successfully reset your password"
            email.body = ViewRenderer.RenderView("~/views/mail/ForgotPasswordEmailTemplate.vbhtml", model:=New ForgotPasswordViewModel With {.email = model.Email, .companyname = user.company.name, .companylogo = user.company.logo, .staffname = user.staff.name, .newpassword = newpassword, .websiteurl = websiteurl})
            email.isbodyhtml = True

            email.DateTimeCreatedUTC = DateTime.Now

            Dim tempr As Result = ims.SendMail(email, user.companyid)
            r.AddErrorsAndWarningsOfAnotherResult(tempr)
        End If

        r.Warnings.Add("Please check your email for new password.")
        MHelper.showresult(r, TempData)
        Return RedirectToAction("Login")
    End Function

    '
    ' GET: /Account/ForgotPassword
    <AllowAnonymous>
    Public Function ForgotPassword() As ActionResult
        Return View()
    End Function

    '
    ' POST: /Account/ForgotPassword
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Async Function ForgotPassword(model As ForgotPasswordViewModel) As Task(Of ActionResult)
        If ModelState.IsValid Then
            Dim user = Await usermanager.FindByNameAsync(model.Email)
            If user Is Nothing OrElse Not (Await usermanager.IsEmailConfirmedAsync(user.Id)) Then
                ' Don't reveal that the user does not exist or is not confirmed
                Return View("ForgotPasswordConfirmation")
            End If
            ' For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
            ' Send an email with this link
            ' Dim code = Await UserManager.GeneratePasswordResetTokenAsync(user.Id)
            ' Dim callbackUrl = Url.Action("ResetPassword", "Account", New With { .userId = user.Id, .code = code }, protocol := Request.Url.Scheme)
            ' Await UserManager.SendEmailAsync(user.Id, "Reset Password", "Please reset your password by clicking <a href=""" & callbackUrl & """>here</a>")
            ' Return RedirectToAction("ForgotPasswordConfirmation", "Account")
        End If

        ' If we got this far, something failed, redisplay form
        Return View(model)
    End Function

    '
    ' GET: /Account/ForgotPasswordConfirmation
    <AllowAnonymous>
    Public Function ForgotPasswordConfirmation() As ActionResult
        Return View()
    End Function

    '
    ' GET: /Account/ResetPassword
    <AllowAnonymous>
    Public Function ResetPassword(code As String) As ActionResult
        Return If(code Is Nothing, View("Error"), View())
    End Function

    '
    ' POST: /Account/ResetPassword
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Async Function ResetPassword(model As ResetPasswordViewModel) As Task(Of ActionResult)
        If Not ModelState.IsValid Then
            Return View(model)
        End If
        Dim user = Await usermanager.FindByNameAsync(model.Email)
        If user Is Nothing Then
            ' Don't reveal that the user does not exist
            Return RedirectToAction("ResetPasswordConfirmation", "Account")
        End If
        Dim result = Await usermanager.ResetPasswordAsync(user.Id, model.Code, model.Password)
        If result.Succeeded Then
            Return RedirectToAction("ResetPasswordConfirmation", "Account")
        End If
        AddErrors(result)
        Return View()
    End Function

    '
    ' GET: /Account/ResetPasswordConfirmation
    <AllowAnonymous>
    Public Function ResetPasswordConfirmation() As ActionResult
        Return View()
    End Function

    '
    ' POST: /Account/ExternalLogin
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Function ExternalLogin(provider As String, returnUrl As String) As ActionResult
        ' Request a redirect to the external login provider
        Return New ChallengeResult(provider, Url.Action("ExternalLoginCallback", "Account", New With {
            .ReturnUrl = returnUrl
        }))
    End Function

    '
    ' POST: /Account/ExternalLogin

    <AllowAnonymous>
    Public Async Function HRClicksExternalLoginAsync(token As String) As Task(Of ActionResult)
        Dim r As New Result

        Dim username As String = ""
        Try
            Dim CallWebService As New MIDAServiceCheckLogin.WSCheckLoginSoapClient
            username = CallWebService.CheckLogin(token)
        Catch ex As Exception
            r.Errors.Add(ex.Message)
        End Try

        If r.isSuccess Then
            If username Is Nothing Then
                r.Errors.Add("Username not found.")
            Else
                username = username & "@mida.gov.my"
                Dim appUser As User = usermanager.FindByName(username)
                If appUser IsNot Nothing Then
                    If appUser.isActive = UserStatus.Inactive Then
                        r.Errors.Add("This user have been deactivated.")
                        MHelper.showresult(r, TempData)
                        Return RedirectToAction("login")
                    End If

                    Await ExternalSignInAsync(appUser)

                    appUser.logoffredirecturl = "http://hr.mida.gov.my"
                    idb.updatesave(appUser)

                    MHelper.showresult(r, TempData, "Hey, " & appUser.staff.name & "! Welcome back!")
                    Return RedirectToAction("", "")
                Else
                    r.Errors.Add("Username not found.")
                End If

            End If
        End If

        MHelper.showresult(r, TempData)
        Return RedirectToAction("ExternalLoginFailure")
    End Function

    '
    ' GET: /Account/SendCode
    <AllowAnonymous>
    Public Async Function SendCode(returnUrl As String, rememberMe As Boolean) As Task(Of ActionResult)
        'Dim userId = Await SignInManager.GetVerifiedUserIdAsync()
        'If userId Is Nothing Then
        '    Return View("Error")
        'End If
        'Dim userFactors = Await UserManager.GetValidTwoFactorProvidersAsync(userId)
        'Dim factorOptions = userFactors.[Select](Function(purpose) New SelectListItem() With {
        '    .Text = purpose,
        '    .Value = purpose
        '}).ToList()
        'Return View(New SendCodeViewModel() With {
        '    .Providers = factorOptions,
        '    .ReturnUrl = returnUrl,
        '    .RememberMe = rememberMe
        '})
    End Function

    '
    ' POST: /Account/SendCode
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Async Function SendCode(model As SendCodeViewModel) As Task(Of ActionResult)
        'If Not ModelState.IsValid Then
        '    Return View()
        'End If

        '' Generate the token and send it
        'If Not Await SignInManager.SendTwoFactorCodeAsync(model.SelectedProvider) Then
        '    Return View("Error")
        'End If
        'Return RedirectToAction("VerifyCode", New With { _
        '    .Provider = model.SelectedProvider,
        '    .ReturnUrl = model.ReturnUrl,
        '    .RememberMe = model.RememberMe
        '})
    End Function

    '
    ' GET: /Account/ExternalLoginCallback
    <AllowAnonymous>
    Public Async Function ExternalLoginCallback(returnUrl As String) As Task(Of ActionResult)
        'Dim loginInfo = Await AuthenticationManager.GetExternalLoginInfoAsync()
        'If loginInfo Is Nothing Then
        '    Return RedirectToAction("Login")
        'End If

        '' Sign in the user with this external login provider if the user already has a login
        'Dim result = Await SignInManager.ExternalSignInAsync(loginInfo, isPersistent := False)
        'Select Case result
        '    Case SignInStatus.Success
        '        Return RedirectToLocal(returnUrl)
        '    Case SignInStatus.LockedOut
        '        Return View("Lockout")
        '    Case SignInStatus.RequiresVerification
        '        Return RedirectToAction("SendCode", New With {
        '            .ReturnUrl = returnUrl,
        '            .RememberMe = False
        '        })
        '    Case Else
        '        ' If the user does not have an account, then prompt the user to create an account
        '        ViewData!ReturnUrl = returnUrl
        '        ViewData!LoginProvider = loginInfo.Login.LoginProvider
        '        Return View("ExternalLoginConfirmation", New ExternalLoginConfirmationViewModel() With {
        '            .Email = loginInfo.Email
        '        })
        'End Select
    End Function



    '
    ' POST: /Account/ExternalLoginConfirmation
    <HttpPost>
    <AllowAnonymous>
    <ValidateAntiForgeryToken>
    Public Async Function ExternalLoginConfirmation(model As ExternalLoginConfirmationViewModel, returnUrl As String) As Task(Of ActionResult)
        If User.Identity.IsAuthenticated Then
            Return RedirectToAction("Index", "Manage")
        End If

        If ModelState.IsValid Then
            ' Get the information about the user from the external login provider
            Dim info = Await AuthenticationManager.GetExternalLoginInfoAsync()
            If info Is Nothing Then
                Return View("ExternalLoginFailure")
            End If
            Dim userInfo = New User() With {
              .UserName = model.Email,
              .Email = model.Email
          }
            Dim result = Await usermanager.CreateAsync(userInfo)
            If result.Succeeded Then
                result = Await usermanager.AddLoginAsync(userInfo.Id, info.Login)
                If result.Succeeded Then
                    Await SignInAsync(userInfo, isPersistent:=False)
                    Return RedirectToLocal(returnUrl)
                End If
            End If
            AddErrors(result)
        End If

        ViewData!ReturnUrl = returnUrl
        Return View(model)
    End Function

    '
    ' GET: /Account/ExternalLoginFailure
    <AllowAnonymous>
    Public Function ExternalLoginFailure() As ActionResult
        Return View()
    End Function

    Protected Overrides Sub Dispose(disposing As Boolean)
        If disposing Then
            If usermanager IsNot Nothing Then
                usermanager.Dispose()
                usermanager = Nothing
            End If
            'If _signInManager IsNot Nothing Then
            '    _signInManager.Dispose()
            '    _signInManager = Nothing
            'End If
        End If

        MyBase.Dispose(disposing)
    End Sub

#Region "Helpers"
    ' Used for XSRF protection when adding external logins
    Private Const XsrfKey As String = "XsrfId"

    Private ReadOnly Property AuthenticationManager() As IAuthenticationManager
        Get
            Return HttpContext.GetOwinContext().Authentication
        End Get
    End Property

    Private Sub AddErrors(result As IdentityResult)
        For Each [error] In result.Errors
            ModelState.AddModelError("", [error])
        Next
    End Sub

    Private Function RedirectToLocal(returnUrl As String) As ActionResult
        If Url.IsLocalUrl(returnUrl) Then
            Return Redirect(returnUrl)
        End If
        Return RedirectToAction("Index", "Home")
    End Function

    Friend Class ChallengeResult
        Inherits HttpUnauthorizedResult
        Public Sub New(provider As String, redirectUri As String)
            Me.New(provider, redirectUri, Nothing)
        End Sub

        Public Sub New(provider As String, redirect As String, user As String)
            LoginProvider = provider
            RedirectUri = redirect
            UserId = user
        End Sub

        Public Property LoginProvider As String
        Public Property RedirectUri As String
        Public Property UserId As String

        Public Overrides Sub ExecuteResult(context As ControllerContext)
            Dim properties = New AuthenticationProperties() With {
                .RedirectUri = RedirectUri
            }
            If UserId IsNot Nothing Then
                properties.Dictionary(XsrfKey) = UserId
            End If
            context.HttpContext.GetOwinContext().Authentication.Challenge(properties, LoginProvider)
        End Sub
    End Class
#End Region

#Region "Company"

    Public Function Company() As ActionResult
        Dim c As Company = idb.Companies.Where(Function(a) a.id = ius.currentcompanyid).FirstOrDefault

        Return View(c)
    End Function

    <HttpPost()>
    Public Function Company(c As Company) As ActionResult
        Dim old As Company = idb.Companies.Where(Function(a) a.id = ius.currentcompanyid).FirstOrDefault

        old.name = c.name
        old.registrationno = c.registrationno
        old.addressstreet1 = c.addressstreet1
        old.addressstreet2 = c.addressstreet2
        old.postcode = c.postcode
        old.city = c.city
        old.state = c.state
        old.country = c.country
        old.email = c.email
        old.fax = c.fax
        old.phone = c.phone
        old.websiteURL = c.websiteURL

        Dim r As Result = idb.updatesave(old, ius.currentuserid, ius.currentcompanyid)

        Return RedirectToAction("Company")
    End Function

    <HttpPost()>
    Function UploadCompanyLogo(Optional file As HttpPostedFileBase = Nothing) As ActionResult
        Dim r As New Result
        Dim old As Company = idb.Companies.Where(Function(a) a.id = ius.currentcompanyid).FirstOrDefault

        If Not old.logo Is Nothing Then
            Dim tempr As New Result

            Dim oldfilename As String = old.logo.Replace("https://authenticventure.blob.core.windows.net/employeeperformance/", "")
            tempr = istorages.Delete(oldfilename)
        End If

        If Not file Is Nothing Then
            If file.ContentLength <= 0 Then
                r.Errors.Add("File length less than 0")
            End If

            Dim originalfilename As String = Path.GetFileName(file.FileName)
            Dim fileExtension As String = Path.GetExtension(file.FileName)

            Dim filename As String = ius.currentcompanyid & Now.Day & Now.Year & Now.Minute & Now.Millisecond

            Using file.InputStream
                Dim r2 = istorages.Save(filename + fileExtension, file.InputStream)
                r.AddErrorsAndWarningsOfAnotherResult(r2)

                If r2.isSuccess Then
                    old.logo = r2.fullurl
                End If
            End Using
        Else
            old.logo = old.logo
        End If

        r = idb.updatesave(old, ius.currentuserid, ius.currentcompanyid)

        MHelper.showresult(r, TempData)

        Return RedirectToAction("Company")
    End Function

    <HttpPost()>
    Public Function UpdateCompanyEmailSetting(c As Company) As ActionResult
        Dim old As Company = idb.Companies.Where(Function(a) a.id = ius.currentcompanyid).FirstOrDefault

        old.usedefaultemailsetting = c.usedefaultemailsetting
        old.emailport = c.emailport
        old.emailhost = c.emailhost
        old.emailfromaddress = c.emailfromaddress
        old.emailusername = c.emailusername
        If Not c.emailpassword = "******" Then
            old.emailpassword = EmployeePerformance.Helpers.Encryptor.Encrypt(c.emailpassword)
        End If
        old.emailenablessl = c.emailenablessl

        Dim r As Result = idb.updatesave(old, ius.currentuserid, ius.currentcompanyid)
        MHelper.showresult(r, TempData)

        Return Redirect(Url.Action("Company") & "#tab_3-3")
    End Function

    Function UpdateBalanceScoreCalculationMethod(c As Company) As ActionResult
        Dim old As Company = idb.Companies.Where(Function(a) a.id = ius.currentcompanyid).FirstOrDefault

        old.balancescorecardmethod = c.balancescorecardmethod

        Dim r As Result = idb.updatesave(old, ius.currentuserid, ius.currentcompanyid)

        If r.isSuccess Then
            If c.balancescorecardmethod = EnumBalanceScorecarCalculationMethod.HundredPercentOnTarget Then
                Dim kpisettingsachievementIsTargeted As KPISettingsAchievement = idb.KPISettingsAchievements.Where(Function(a) a.companyid = ius.currentcompanyid And a.istarget = True).FirstOrDefault

                If kpisettingsachievementIsTargeted Is Nothing Then
                    Dim lastlevelkpisettingsachievement As KPISettingsAchievement = idb.KPISettingsAchievements.Where(Function(a) a.companyid = ius.currentcompanyid).OrderBy(Function(a) a.level).LastOrDefault
                    If Not lastlevelkpisettingsachievement Is Nothing Then
                        lastlevelkpisettingsachievement.istarget = True

                        Dim r2 As Result = idb.updatesave(lastlevelkpisettingsachievement, ius.currentuserid, ius.currentcompanyid)
                        r.AddErrorsAndWarningsOfAnotherResultAsWarning(r2)
                    End If
                End If
            ElseIf c.balancescorecardmethod = EnumBalanceScorecarCalculationMethod.ModifiableThresholdPercent Then
                Dim kpisettingsachievements As List(Of KPISettingsAchievement) = idb.KPISettingsAchievements.Where(Function(a) a.companyid = ius.currentcompanyid).ToList

                For Each item In kpisettingsachievements
                    If item.defaultscore Is Nothing Then
                        item.defaultscore = 0

                        Dim r2 As Result = idb.updatesave(item, ius.currentuserid, ius.currentcompanyid)
                        r.AddErrorsAndWarningsOfAnotherResultAsWarning(r2)
                    End If
                Next
            End If
        End If

        MHelper.showinfo("Please make sure you re-configure THRESHOLD SETTINGS in Configuration > KPIs > Level & Threshold", TempData)
        MHelper.showresult(r, TempData)
        Return Redirect(Url.Action("Company") & "#tab_4-4")
    End Function

#End Region
End Class

Public Class ResultResponse

    Public Sub New()
        Me.errors = New List(Of String)
        Me.warnings = New List(Of String)
    End Sub

    ' capitalization matters! if API is lower-case, use lower case
    Public Property isSuccess As Boolean
    Public Property errors As ICollection(Of String)
    Public Property warnings As ICollection(Of String)
End Class

Public Class ApiHRClicksExternalLogin
    Public Property username As String
End Class