示例#1
0
        protected void ctlSave_Click(object sender, ImageClickEventArgs e)
        {
            try
            {
                this.WorkflowID = ctlAdvanceDocumentEditor.Save();
                //if create document from ta not show message "send to workflow" else must be show message "send to workflow"
                if (this.WorkflowID > 0 && ctlHiddenTaDocument.Value != "TADocument")
                {
                    ShowComfirmPopup();
                }
            }
            catch (ServiceValidationException ex)
            {
                this.ValidationErrors.MergeErrors(ex.ValidationErrors);
                ctlUpdatePanelValidation.Update();
            }
            if (ctlHiddenTaDocument.Value == "TADocument")
            {
                if (this.ValidationErrors.IsEmpty)
                {
                    //Modify by tom 07/06/2009, redirect to TAFrom
                    //Response.Redirect("DocumentView.aspx?wfid=" + this.WorkflowID.ToString());

                    long taDocumentID = UIHelper.ParseLong(Request.QueryString["taDocumentID"]);

                    TADocument taDocument = ScgeAccountingQueryProvider.TADocumentQuery.FindProxyByIdentity(taDocumentID);
                    WorkFlow   workFlow   = WorkFlowQueryProvider.WorkFlowQuery.GetWorkFlowByDocumentID(taDocument.DocumentID.DocumentID);

                    Response.Redirect("DocumentView.aspx?wfid=" + workFlow.WorkFlowID + "&eventFlag=" + PopUpReturnType.Add.ToString());
                }
            }
        }
        protected void ctlTALookupPopupCaller_NotifyPopupResult(object sender, string action, string value)
        {
            if (action != "ok") return;

            object returnValue = new object();

            if (!isMultiple)
            {
                IList<TADocumentObj> taDocument = ScgeAccountingQueryProvider.SCGDocumentQuery.FindByDocumentIdentity(UIHelper.ParseLong(value));
                returnValue = taDocument[0];
                CallOnObjectLookUpReturn(returnValue);
            }
            else
            {
                string[] listID = value.Split('|');
                IList<TADocument> list = new List<TADocument>();
                foreach (string id in listID)
                {
                    TADocument taDocument = ScgeAccountingQueryProvider.TADocumentQuery.FindByIdentity(UIHelper.ParseLong(id));
                    if (taDocument != null)
                        list.Add(taDocument);
                }
                returnValue = list;
                CallOnObjectLookUpReturn(returnValue);
            }
        }
        public void PrepareAdvance(IList <SCG.eAccounting.DTO.ValueObject.Advance> advanceList)
        {
            foreach (SCG.eAccounting.DTO.ValueObject.Advance advance in advanceList)
            {
                AvAdvanceDocument advanceDocument = ScgeAccountingQueryProvider.AvAdvanceDocumentQuery.FindProxyByIdentity(advance.AdvanceID);
                if (advanceDocument.TADocumentID != null && advanceDocument.TADocumentID != 0)
                {
                    // For query only advance that
                    // 1. Status = OutStanding
                    // 2. Do not used in Expense that has flag <> 'Cancel'
                    SCG.eAccounting.DTO.ValueObject.Advance avCriteria = new SCG.eAccounting.DTO.ValueObject.Advance();
                    avCriteria.CompanyID    = CompanyID;
                    avCriteria.RequesterID  = RequesterID;
                    avCriteria.AdvanceType  = FnExpenseDocumentService.GetExpenseType(this.ExpDocumentID, this.TransactionId);
                    advance.ExpenseType     = avCriteria.AdvanceType;
                    avCriteria.TADocumentID = advanceDocument.TADocumentID;

                    //Delete all advance and remittance in ExpenseAdvance Datatable.
                    //กรณีที่มีรายการ advance ที่อ้างอิง TA อยู่ใน advanceList ที่เลือกมา
                    this.ClearAdvanceGridview();
                    //this.ClearRemittanceGridview();

                    FnExpenseDocumentService.SetTA(this.TransactionId, this.ExpDocumentID, avCriteria);

                    TADocument ta = ScgeAccountingQueryProvider.TADocumentQuery.FindByIdentity(advanceDocument.TADocumentID.Value);
                    SS.Standard.WorkFlow.DTO.WorkFlow wf = SS.Standard.WorkFlow.Query.WorkFlowQueryProvider.WorkFlowQuery.GetWorkFlowByDocumentID(ta.DocumentID.DocumentID);

                    ctlTANoLabel.Visible          = false;
                    ctlTALinkButton.Text          = ta.DocumentID.DocumentNo;
                    ctlTALinkButton.OnClientClick = "window.open('../Programs/DocumentView.aspx?wfid=" + wf.WorkFlowID.ToString() + "')";
                    ctlBusinessChk.Checked        = ta.IsBusinessPurpose;
                    ctlTrainingChk.Checked        = ta.IsTrainningPurpose;
                    ctlOtherChk.Checked           = ta.IsOtherPurpose;
                    ctlOther.Text         = ta.OtherPurposeDescription;
                    ctlCountry.Text       = ta.Country;
                    ctlFromDateCal.Value  = ta.FromDate;
                    ctlToDateCal.Value    = ta.ToDate;
                    ctlAddAdvance.Enabled = false;

                    ctlAdvanceGridView.Columns[7].Visible = false;
                    ctlTANoLookup.Enabled = true;
                    ctlDeleteTA.Enabled   = true;

                    break;
                }
                else
                {
                    double totalAdvance = FnExpenseDocumentService.AddExpenseAdvanceToTransaction(this.TransactionId, this.ExpDocumentID, advanceList, 0);
                    FnExpenseDocumentService.SetTotalAdvance(this.TransactionId, 0, totalAdvance);
                    FnExpenseDocumentService.RefreshRemittance(this.TransactionId, this.ExpDocumentID);
                    //break;
                }
            }
        }
        public void BindControl(bool refreshHeader)
        {
            this.refreshHeaderGrid = refreshHeader;
            if (InitialFlag.Equals(FlagEnum.ViewFlag))
            {
                ctlAddAdvance.Enabled = false;
                ctlTANoLookup.Visible = false;
                ctlDeleteTA.Visible   = false;
            }
            else
            {
                ctlAddAdvance.Enabled = true;
                ctlTANoLookup.Visible = true;
                ctlDeleteTA.Visible   = true;
            }

            if (this.DocumentType.Equals(ZoneType.Domestic))
            {
                this.IsDomestic = true;
                ctlRemittanceGridview.Visible = false;
                ctlTALookup.TravelBy          = TravellBy.Domestic;
                ctlControlPanel.Visible       = false;
            }
            else
            {
                this.IsDomestic = false;
                ctlRemittanceGridview.Visible = true;
                ctlTALookup.TravelBy          = TravellBy.Foreign;
                ctlControlPanel.Visible       = true;
            }

            ExpenseDataSet expenseDS = (ExpenseDataSet)TransactionService.GetDS(this.TransactionId);

            ExpenseDataSet.FnExpenseDocumentRow row = expenseDS.FnExpenseDocument.FindByExpenseID(this.ExpDocumentID);
            if (!row.IsTADocumentIDNull())
            {
                ctlTANoLookup.Enabled = false;
                TADocument ta = ScgeAccountingQueryProvider.TADocumentQuery.FindByIdentity(row.TADocumentID);
                SS.Standard.WorkFlow.DTO.WorkFlow wf = SS.Standard.WorkFlow.Query.WorkFlowQueryProvider.WorkFlowQuery.GetWorkFlowByDocumentID(ta.DocumentID.DocumentID);
                ctlAddAdvance.Enabled         = false;
                ctlTANoLabel.Visible          = false;
                ctlTALinkButton.Text          = ta.DocumentID.DocumentNo;
                ctlTALinkButton.OnClientClick = "window.open('../Programs/DocumentView.aspx?wfid=" + wf.WorkFlowID.ToString() + "')";
                ctlBusinessChk.Checked        = !(row.IsIsBusinessPurposeNull() || row.IsBusinessPurpose == false);
                ctlTrainingChk.Checked        = !(row.IsIsTrainningPurposeNull() || row.IsTrainningPurpose == false);
                ctlOtherChk.Checked           = !(row.IsIsOtherPurposeNull() || row.IsOtherPurpose == false);
                ctlOther.Text   = row.IsOtherPurposeDescriptionNull() ? String.Empty : row.OtherPurposeDescription;
                ctlCountry.Text = row.IsCountryNull() ? String.Empty : row.Country;

                if (!row.IsFromDateNull())
                {
                    ctlFromDateCal.Value = row.FromDate;
                }
                if (!row.IsToDateNull())
                {
                    ctlToDateCal.Value = row.ToDate;
                }

                ctlPersonLevel.Text            = row.IsPersonalLevelNull() ? String.Empty : row.PersonalLevel;
                ctlExchangeRateForPerdiem.Text = row.IsExchangeRateForUSDAdvanceNull() ? String.Empty : row.ExchangeRateForUSDAdvance.ToString();
            }
            else
            {
                ResetTADataZone();
                if (expenseDS.FnExpenseAdvance.Rows.Count > 0)
                {
                    ctlTANoLookup.Enabled = false;
                    ctlDeleteTA.Enabled   = false;
                }
            }

            BindAdvanceGridView();
            BindRemittanceGridview();
            ctlUpdatePanelExpenseGeneral.Update();
        }
        public void SendSMS01(long workFlowID, long sendToUserID)
        {
            try
            {
                if (ParameterServices.EnableSMS)
                {
                    string tokenSMSCode = SaveResponseTokenSMS(workFlowID, sendToUserID);

                    SuUser sendToUser = QueryProvider.SuUserQuery.FindByIdentity(sendToUserID);
                    if (sendToUser.SMSApproveOrReject)
                    {
                        IList <WorkFlowResponseToken> responseTokens = WorkFlowQueryProvider.WorkFlowResponseTokenQuery.FindByTokenCode(tokenSMSCode);
                        Document    document      = WorkFlowQueryProvider.WorkFlowQuery.GetDocumentByWorkFlowID(workFlowID);
                        SCGDocument scgDocument   = ScgeAccountingQueryProvider.SCGDocumentQuery.FindByIdentity(document.DocumentID);
                        SuUser      RequesterUser = QueryProvider.SuUserQuery.FindByIdentity(scgDocument.RequesterID.Userid);

                        SMSDTO smsDto = new SMSDTO();
                        smsDto.From = SS.DB.Query.ParameterServices.SMSPhoneNumber;
                        string Mobile = "66" + sendToUser.MobilePhoneNo.ToString().Remove(0, 1);
                        smsDto.To          = Mobile;
                        smsDto.ReferenceID = tokenSMSCode;
                        smsDto.Requestor   = RequesterUser.UserName;
                        smsDto.DocumentNo  = scgDocument.DocumentNo;
                        smsDto.UseProxy    = true;
                        if (scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.AdvanceDomesticDocument) || scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.AdvanceForeignDocument))
                        {
                            AvAdvanceDocument avanceDocument = ScgeAccountingQueryProvider.AvAdvanceDocumentQuery.GetAvAdvanceByDocumentID(scgDocument.DocumentID);
                            if (scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.AdvanceForeignDocument))
                            {
                                //ต่างประเทศจะต้องไป get Currency Symbol ออกมา
                                if (avanceDocument != null)
                                {
                                    smsDto.Amount = avanceDocument.Amount.ToString();
                                }
                                else
                                {
                                    smsDto.Amount = "0";
                                }
                                IList <AvAdvanceItem>  advanceItemList = ScgeAccountingQueryProvider.AvAdvanceItemQuery.FindByAvAdvanceItemAdvanceID(avanceDocument.AdvanceID);
                                IList <SMSCurrencyDTO> advItemList     = new List <SMSCurrencyDTO>();
                                foreach (AvAdvanceItem advanceItem in advanceItemList)
                                {
                                    string         dbStatus = ScgDbQueryProvider.SCGDbStatusLangQuery.GetStatusLang("PaymentTypeFRN", ParameterServices.DefaultLanguage, advanceItem.PaymentType);
                                    SMSCurrencyDTO advItem  = new SMSCurrencyDTO();
                                    advItem.PaymentType = dbStatus;
                                    if (advanceItem.CurrencyID != null)
                                    {
                                        advItem.Currency = advanceItem.CurrencyID.Symbol;
                                    }
                                    advItem.Amount = advanceItem.Amount.ToString();
                                    advItemList.Add(advItem);
                                }
                                smsDto.CurrencyItemList = advItemList;

                                smsDto.Content = BuildContentBody(smsDto, SMSContenFormat.SMS01, SMSBusinessCase.AdvanceForeignDocument);
                            }
                            else
                            {
                                //ในประเทศ Currency Symbol THB เท่านั้น
                                if (avanceDocument != null)
                                {
                                    smsDto.Amount = avanceDocument.Amount.ToString();
                                }
                                else
                                {
                                    smsDto.Amount = "0";
                                }
                                smsDto.Content = BuildContentBody(smsDto, SMSContenFormat.SMS01, SMSBusinessCase.AdvanceDomesticDocument);
                            }
                            this.sendSMSStatus = SMSService.Send(smsDto);
                        }
                        else if (scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.ExpenseDomesticDocument) || scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.ExpenseForeignDocument))
                        {
                            FnExpenseDocument expenseDocument = ScgeAccountingQueryProvider.FnExpenseDocumentQuery.GetExpenseDocumentByDocumentID(scgDocument.DocumentID);

                            if (scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.ExpenseForeignDocument))
                            {
                                FnExpenseDocument expense = ScgeAccountingQueryProvider.FnExpenseDocumentQuery.GetExpenseDocumentByDocumentID(scgDocument.DocumentID);
                                //EmailValueObject expenseDoc = new EmailValueObject();
                                // expenseDoc.RequestID = expense.Document.DocumentNo;

                                smsDto.Amount  = expense.TotalExpense.ToString();
                                smsDto.Content = BuildContentBody(smsDto, SMSContenFormat.SMS01, SMSBusinessCase.ExpenseDomesticDocument);
                            }
                            else
                            {
                                if (expenseDocument != null)
                                {
                                    smsDto.Amount = expenseDocument.TotalExpense.ToString();
                                }
                                else
                                {
                                    smsDto.Amount = "0";
                                }
                                smsDto.Content = BuildContentBody(smsDto, SMSContenFormat.SMS01, SMSBusinessCase.ExpenseDomesticDocument);
                            }

                            this.sendSMSStatus = SMSService.Send(smsDto);
                        }
                        else if (scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.TADocumentDomestic) || scgDocument.DocumentType.DocumentTypeID.Equals(DocumentTypeID.TADocumentForeign))
                        {
                            TADocument      ta          = ScgeAccountingQueryProvider.TADocumentQuery.GetTADocumentByDocumentID(scgDocument.DocumentID);
                            IList <Advance> advanceList = ScgeAccountingQueryProvider.AvAdvanceDocumentQuery.FindAdvanceDocumentByTADocumentID(ta.TADocumentID);
                            if (advanceList.Count > 0)
                            {
                                IList <AdvanceData> advanceDataList = new List <AdvanceData>();
                                foreach (Advance advance in advanceList)
                                {
                                    AdvanceData       advanceData = new AdvanceData();
                                    AvAdvanceDocument advDocument = ScgeAccountingQueryProvider.AvAdvanceDocumentQuery.FindByIdentity(advance.AdvanceID);
                                    if (advDocument != null)
                                    {
                                        //advanceData.RequestID = advDocument.DocumentID.RequesterID;
                                        advanceData.Subject = advDocument.DocumentID.Subject;
                                        advanceData.RequestDateOfAdvance = advDocument.RequestDateOfAdvance;
                                        advanceData.Amount = advDocument.Amount;
                                        if (advDocument.AdvanceType.Equals("FR"))
                                        {
                                            IList <AvAdvanceItem>  advItemList   = ScgeAccountingQueryProvider.AvAdvanceItemQuery.FindByAvAdvanceItemAdvanceID(advDocument.AdvanceID);
                                            IList <SMSCurrencyDTO> advanceFrList = new List <SMSCurrencyDTO>();
                                            foreach (AvAdvanceItem advItem in advItemList)
                                            {
                                                SMSCurrencyDTO advanceFR = new SMSCurrencyDTO();
                                                advanceFR.Currency = advItem.CurrencyID.Symbol;
                                                advanceFR.Amount   = advItem.Amount.ToString();
                                                advanceFrList.Add(advanceFR);
                                            }
                                            smsDto.CurrencyItemList = advanceFrList;
                                        }
                                        advanceDataList.Add(advanceData);
                                    }
                                }
                                // html.SetAttribute("advList", advanceDataList);
                            }
                            // html.SetAttribute("ta", taDoc);

                            smsDto.Content = BuildContentBody(smsDto, SMSContenFormat.SMS01, SMSBusinessCase.TADocumentDomestic);



                            this.sendSMSStatus = SMSService.Send(smsDto);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Utilities.WriteLogs("SendSMS01 : " + ex.Message, "smslog", "Logs", "txt");
            }
        }
示例#6
0
        public AdvanceDataSet PrepareDataToDsTA(long taDocumentID)
        {
            AdvanceDataSet advanceDs = new AdvanceDataSet();
            //ดึงจาก base มาใส่ใน DataSet
            TADocument taDoc = ScgeAccountingQueryProvider.TADocumentQuery.FindProxyByIdentity(taDocumentID);

            Spring.Validation.ValidationErrors errors = new Spring.Validation.ValidationErrors();

            if (taDoc == null)
            {
                errors.AddError("Provider.Error", new Spring.Validation.ErrorMessage("NoTADocumentFound"));
            }
            if (!errors.IsEmpty)
            {
                throw new ServiceValidationException(errors);
            }
            // Prepare Data to Document datatable.

            AdvanceDataSet.DocumentRow docRow = advanceDs.Document.NewDocumentRow();
            docRow.ApproverID  = taDoc.DocumentID.ApproverID.Userid;
            docRow.RequesterID = taDoc.DocumentID.RequesterID.Userid;
            docRow.RequesterID = taDoc.DocumentID.RequesterID.Userid;
            docRow.CreatorID   = taDoc.DocumentID.CreatorID.Userid;
            docRow.CompanyID   = taDoc.DocumentID.CompanyID.CompanyID;
            advanceDs.Document.AddDocumentRow(docRow);


            IList <DocumentInitiator> documentInitiatorList = new List <DocumentInitiator>();

            documentInitiatorList = ScgeAccountingQueryProvider.DocumentInitiatorQuery.GetDocumentInitiatorByDocumentID(taDoc.DocumentID.DocumentID);
            foreach (DocumentInitiator initiator in documentInitiatorList)
            {
                // Set data to document initiator datatable.
                AdvanceDataSet.DocumentInitiatorRow docInitial = advanceDs.DocumentInitiator.NewDocumentInitiatorRow();
                //docInitial.ini = initiator.InitiatorID;
                //if (initiator.DocumentID != null)
                //{
                //    initiatorRow["DocumentID"] = initiator.DocumentID.DocumentID;
                //}
                docInitial.InitiatorType = initiator.InitiatorType;
                docInitial.Seq           = initiator.Seq;
                if (initiator.UserID != null)
                {
                    docInitial.UserID = initiator.UserID.Userid;
                }
                docInitial.DoApprove = initiator.DoApprove;
                docInitial.Active    = initiator.Active;
                docInitial.CreBy     = initiator.CreBy;
                docInitial.CreDate   = initiator.CreDate;
                docInitial.UpdBy     = initiator.UpdBy;
                docInitial.UpdDate   = initiator.UpdDate;
                docInitial.UpdPgm    = initiator.UpdPgm;

                // Add document initiator to datatable budgetDocumentDS.
                advanceDs.DocumentInitiator.AddDocumentInitiatorRow(docInitial);
            }
            advanceDs.DocumentAttachment.NewDocumentAttachmentRow();

            // Set data to Advance Document row in advanceDs.
            AdvanceDataSet.AvAdvanceDocumentRow avRow = advanceDs.AvAdvanceDocument.NewAvAdvanceDocumentRow();
            //avRow.AdvanceID = -1;
            avRow.DocumentID   = Convert.ToInt64(advanceDs.Document.Rows[0]["DocumentID"].ToString());
            avRow.TADocumentID = taDoc.TADocumentID;
            //avRow.AdvanceType = taDoc.;
            //if (avDb.PBID != null && avDb.PBID.Pbid > 0)
            //    avRow.PBID = avDb.PBID.Pbid;
            //else
            //    avRow.SetPBIDNull();
            //avRow.ServiceTeamID = avDb.ServiceTeamID.ServiceTeamID;
            if (taDoc.TravelBy.Equals(TravellBy.Foreign))
            {
                avRow.ArrivalDate = taDoc.ToDate;
                avRow.AdvanceType = ZoneType.Foreign;
            }
            else
            {
                avRow.AdvanceType = ZoneType.Domestic;
            }
            //avRow.RequestDateOfAdvance = avDb.RequestDateOfAdvance;
            //avRow.DueDateOfRemittance = avDb.DueDateOfRemittance;
            //avRow.RequestDateOfRemittance = avDb.RequestDateOfRemittance;
            //if (avDb.AdvanceType == ZoneType.Foreign)
            //    avRow.ArrivalDate = avDb.ArrivalDate.Value;
            //avRow.Reason = avDb.Reason;
            //avRow.PerDiemExRateUSD = (decimal)avDb.PerDiemExRateUSD;
            //avRow.Amount = (decimal)avDb.Amount;
            //avRow.RemittanceAmount = (decimal)avDb.RemittanceAmount;
            //avRow.ExpenseAmount = (decimal)avDb.ExpenseAmount;
            avRow.Active  = true;
            avRow.CreBy   = UserAccount.UserID;
            avRow.CreDate = DateTime.Now;
            avRow.UpdBy   = UserAccount.UserID;
            avRow.UpdDate = DateTime.Now;
            avRow.UpdPgm  = UserAccount.CurrentProgramCode;
            advanceDs.AvAdvanceDocument.AddAvAdvanceDocumentRow(avRow);

            // Prepare Data to AvAdvanceItem Datatable.
            AvAdvanceItemService.PrepareDataToDataset(advanceDs, avRow.AdvanceID, false);

            //advanceDs.AcceptChanges();
            return(advanceDs);
        }