Beispiel #1
0
 public void ValidateRefundApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != RefundValid)
     {
         RefundValid(null, args);
     }
 }
Beispiel #2
0
 public void ValidateAppealApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != Approve)
     {
         Approve(null, args);
     }
 }
Beispiel #3
0
 public void RejectRefundApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != RefundRejected)
     {
         RefundRejected(null, args);
     }
 }
 public void ApproveRefundApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != Approve)
     {
         Approve(null, args);
     }
 }
 public void ValidateAdjudicationApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != AdjudicationValid)
     {
         AdjudicationValid(null, args);
     }
 }
Beispiel #6
0
 public void RejectAppealApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != Reject)
     {
         Reject(null, args);
     }
 }
 public void InvalidateLicenseApplication(Guid InstanceId, FeedbackEventArgs args)
 {
     if (null != Reject)
     {
         Reject(null, args);
     }
 }
Beispiel #8
0
        /// <summary>
        /// Updating RefundApplication records
        /// </summary>
        /// <param name="Parameter">Formview parameter</param>
        /// <param name="StampDetails">Datatable of stampdetails</param>
        /// <param name="ActsApplicable">Datatable of ActsApplicable</param>
        /// <param name="RefundApplicationId">The Primary key of RefundApplication table</param>
        /// <param name="AlertId">AlertId</param>
        /// <param name="Verified">Verified</param>
        /// <returns>true, a record updated sucessfully</returns>
        public bool UpdateRefundApplicationNew(FormViewParameter Parameter, DataTable StampDetails, DataTable ActsApplicable, Guid RefundApplicationId, Guid AlertId, bool Verified)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;
            try
            {
                #region This functionality must be done in Workflow
                //IGRSS.DataAccessLayer.Refund.RefundApplicationRow row = (RefundApplicationRow) Parameter.Values;
                //IgrssAdapters.RefundApplicationAdapter.UpdateRefundApplication(RefundApplicationId, row.OfficeId, row.RegistrationNo,
                //    row.RefundPrefix, row.RefundSlNo, row.RefundYear, row.TypeOfRefund, row.ApplicationDate, row.VendorLicenseId,
                //    row.PurchasedDate, row.TotalValueOfStamps, row.ReasonForNotUsing, row.ApplicantName, row.ApplicantAddress,
                //    row.City, row.District, row.PinCode, row.PhoneNo, row.Remarks);

                //IgrssAdapters.RefundStampDetailsAdapter.DeleteRefundStampDetails(RefundApplicationId);
                //foreach (DataRow StampDetail in StampDetails.Rows)
                //{
                //    IgrssAdapters.RefundStampDetailsAdapter.InsertStampDetails(RefundApplicationId, (Guid) StampDetail["RevenueStampId"], (string) StampDetail["ReturnedQty"], (string) StampDetail["StampNumber"]);
                //}

                //IgrssAdapters.RefundActsApplicable.DeleteRefundOrders(RefundApplicationId);
                //foreach (DataRow Act in ActsApplicable.Rows)
                //{
                //    IgrssAdapters.RefundActsApplicable.InsertRefundActsApplicable(RefundApplicationId, (Guid) Act["ActId"], (bool) Act["Checked"], "");
                //}
                #endregion

                // Get the Workflow Instance Id from table
                Guid WfInstanceId = (Guid)IgrssAdapters.RefundApplicationAdapter.GetWorkflowInstanceById(RefundApplicationId);
                // Check if the user has verified the application or just updated
                if (Verified)
                {
                    // Create the FeedbackEventArgs object
                    FeedbackEventArgs args = new FeedbackEventArgs(WfInstanceId, AlertId, curUser);
                    WorkflowMediator.RefundServices.ValidateRefundApplication(WfInstanceId, args);
                }
                else
                {
                    // The record has not been verified just updated
                    RefundApplicationUpdatedEventArgs args = new RefundApplicationUpdatedEventArgs(WfInstanceId, (RefundApplicationRow)Parameter.Values, StampDetails, ActsApplicable);
                    WorkflowMediator.RefundServices.UpdateRefundApplication(WfInstanceId, args);
                }
            }
            catch (Exception ex)
            {
                if (ExceptionPolicy.HandleException(ex, "DAL"))
                    throw;
            }
            return true;
        }
        public bool UpdateAdjudicationRequestById(FormViewParameter ValFormParameter, AdjudicationRequestRow AdjReqRow, DataTable FeeDetails, DataTable DocDetails, Guid ValuationId, Guid AdjudicationId, Guid AlertId, bool Verified)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;

            // Get the Workflow Instance Id from table
            Guid WfInstanceId = (Guid)IgrssAdapters.ValuationAdapter.GetAdjudicationWorkFlowInstanceId(ValuationId);

            // Check if the user has verified the application or just updated
            if (Verified)
            {
                // Create the FeedbackEventArgs object
                FeedbackEventArgs args = new FeedbackEventArgs(WfInstanceId, AlertId, curUser);
                WorkflowMediator.AdjudicationServices.ValidateAdjudicationApplication(WfInstanceId, args);
            }
            else
            {
                // The record has not been verified just updated
                AdjudicationApplicationUpdatedEventArgs args = new AdjudicationApplicationUpdatedEventArgs(WfInstanceId, AdjReqRow, (ValuationFormRow) ValFormParameter.Values, FeeDetails, DocDetails);
                     //AppealApplicationUpdatedEventArgs args = new AppealApplicationUpdatedEventArgs(WfInstanceId, (AppealApplicationRow)parameter.Values, dtAct);
                 WorkflowMediator.AdjudicationServices.UpdateAdjudicationApplication(WfInstanceId, args);
            }

            return true;
        }
Beispiel #10
0
        // public bool Renewvendorlicense(DateTime EffectiveDate,DateTime ExpiryDate,Guid LicenseApplicationId)
        //{
        //  string UserName=Thread.CurrentPrincipal.Identity.Name;
        //  IgrssAdapters.LicRenewAdapter.RenewVendorLicense(Guid.NewGuid(), LicenseApplicationId, DateTime.Now, DateTime.Now, EffectiveDate, ExpiryDate);
        //  return true;
        //}
        /// <summary>
        /// This function will approve the vendor application and issue the new License
        /// </summary>
        /// <param name="EffectiveDate"></param>
        /// <param name="IssueDate"></param>
        /// <param name="LicenseNo"></param>
        /// <param name="ExpiryDate"></param>
        /// <param name="LicenseApplicationID"></param>
        /// <returns>boolean</returns>
        public bool ApprovedVendorLicense(Guid LicenseApplicationID, string LicenseNo, DateTime IssueDate, DateTime EffectiveDate, DateTime ExpiryDate, Guid AlertId)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;
            try
            {
                Guid InstanceId = (Guid)IgrssAdapters.LAppTableAdapter.GetWfIdByLicenseApplicationId(LicenseApplicationID);
                FeedbackEventArgs args = new FeedbackEventArgs(InstanceId, AlertId, curUser);

                WorkflowMediator.LicenseApplicationServices.ApproveLicenseApplication(InstanceId, args);

                IgrssAdapters.LAppTableAdapter.ApproveVendorLicense(LicenseApplicationID, LicenseNo, IssueDate, EffectiveDate, ExpiryDate);
                return true;
            }
            catch (Exception ex)
            {
                if (ExceptionPolicy.HandleException(ex, "DAL"))
                    throw;
                return false;
            }
            return true;
        }
Beispiel #11
0
        /// <summary>
        /// This function will update the vendor record
        /// </summary>
        /// <param name="Parameter">Contains all the fields of the formview</param>
        /// <returns>boolean</returns>
        public bool updateVendorsDetail(FormViewParameter Parameter, bool Verified, Guid AlertId, Guid LicenseApplicationId, Remarks rem)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;
            try
            {
                if ((rem.Body != "") || (rem.Subject != ""))
                {
                    FileManager.AddRemarkToFile(LicenseApplicationId, rem.Subject, rem.Body);
                }
                //IgrssAdapters.LAppTableAdapter.UpdateVendorDetails(row.ApplnNumber, row.NameOfApplicant, row.PresentAddress, row.PermanentAddress, row.DateOfBirth, DateTime.Now, row.Qualification, row.Experience, row.Caste, row.BusinessAddress, row.TotalInvestmentAmount, row.NameAndAddressOfReferer, row.SubmissionOfficeId, row.HomePhone, row.Remarks,LicenseApplicationId);
                Guid InstanceId = (Guid)IgrssAdapters.LAppTableAdapter.GetWfIdByLicenseApplicationId(LicenseApplicationId);
                if (Verified)
                {
                    FeedbackEventArgs args = new FeedbackEventArgs(InstanceId, AlertId, curUser);
                    WorkflowMediator.LicenseApplicationServices.ValidateLicenseApplication(InstanceId, args);
                }
                else
                {
                    ApplicationUpdatedEventArgs args = new ApplicationUpdatedEventArgs(InstanceId, (LicenseApplicationRow)Parameter.Values);
                    WorkflowMediator.LicenseApplicationServices.UpdateApplication(InstanceId, args);
                }

                //Guid InstanceId = (Guid) IgrssAdapters.ComplainAdapter.GetWfIdByComplainId(ComplainId);
                //InvestigationRequiredEventArgs args = new InvestigationRequiredEventArgs(InstanceId);
                //args.InvestigatingOfficer = InvestigatingOfficer;
                //WorkflowMediator.ComplainServices.RequireInvestigation(InstanceId, args);
                return true;

            }
            catch (Exception ex)
            {
                if (ExceptionPolicy.HandleException(ex, "DAL"))
                    throw;
                return false;
            }
        }
Beispiel #12
0
        /// <summary>
        /// This function will cancel the vendor application
        /// </summary>
        /// <param name="LicenseApplicationID"></param>
        /// <returns>boolean</returns>
        public bool RejectVenorLicense(Guid LicenseApplicationID)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;
            try
            {
                Guid InstanceId = (Guid)IgrssAdapters.LAppTableAdapter.GetWfIdByLicenseApplicationId(LicenseApplicationID);
                FeedbackEventArgs args = new FeedbackEventArgs(InstanceId, Guid.Empty, curUser);

                WorkflowMediator.LicenseApplicationServices.RejectLicenseApplication(InstanceId, args);

                IgrssAdapters.LAppTableAdapter.RejectVendorLicense(LicenseApplicationID);
                return true;
            }
            catch (Exception ex)
            {
                if (ExceptionPolicy.HandleException(ex, "DAL"))
                    throw;
                return false;
            }
        }
Beispiel #13
0
        public bool UpdateAppealAplication(FormViewParameter parameter, DataTable dtAct, Guid AppealApplicationId, Guid AlertId, bool Verified)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;
            try
            {
                IGRSS.DataAccessLayer.Appeal.AppealApplicationRow row = (IGRSS.DataAccessLayer.Appeal.AppealApplicationRow)parameter.Values;
                IgrssAdapters.AppealAdapter.UpdateAppealApplication(AppealApplicationId, row.RegistrationNo, row.ApplicantName, row.Address, row.CalculatedAmount, row.DepositAmount, row.FeeReceiptNo, row.Amount, row.InwardDate, row.IsPaidAppealFee, row.AppealInTime, row.PaperFromTo, row.OfficeId, row.CourtFeeTicket, row.TypeOfAppeal, curUser, DateTime.Now, row.DocumentNo, row.OriginalSRO, row.DocumentDate, row.DaTeOffOrderFromCollector, row.DficitAmount, row.ReceiptNo, row.ReceiptDate);
                IgrssAdapters.AppealActAdapter.DeleteAppealActsByAppealApplicationId(AppealApplicationId);
                foreach (DataRow dr in dtAct.Rows)
                {
                    IgrssAdapters.AppealActAdapter.AddAppealAct(AppealApplicationId, (Guid)dr["ActId"], (bool)dr["Checked"]);
                }

                // Get the Workflow Instance Id from table
                Guid WfInstanceId = (Guid)IgrssAdapters.AppealAdapter.GetWorkflowInstanceById(AppealApplicationId);

                // Check if the user has verified the application or just updated
                if (Verified)
                {
                    // Create the FeedbackEventArgs object
                    FeedbackEventArgs args = new FeedbackEventArgs(WfInstanceId, AlertId, curUser);
                    WorkflowMediator.AppealServices.ValidateAppealApplication(WfInstanceId, args);
                }
                else
                {
                    // The record has not been verified just updated
                    AppealApplicationUpdatedEventArgs args = new AppealApplicationUpdatedEventArgs(WfInstanceId, (AppealApplicationRow) parameter.Values, dtAct);
                    WorkflowMediator.AppealServices.UpdateAppealApplication(WfInstanceId, args);
                }
                return true;

            }
            catch (Exception ex)
            {
                if (ExceptionPolicy.HandleException(ex, "DAL"))
                    throw;
                return false;

            }
        }
Beispiel #14
0
        public bool ApproveAppealApplication(Guid AppealApplicationId,Guid AlertId)
        {
            string curUser = Thread.CurrentPrincipal.Identity.Name;
            try
            {
                // Get the Workflow Instance Id for the Appeal Application
                Guid WfInstanceId = (Guid)IgrssAdapters.AppealAdapter.GetWorkflowInstanceById(AppealApplicationId);
                // Create Feedback Event Args object for the current feedback
                FeedbackEventArgs args = new FeedbackEventArgs(WfInstanceId, AlertId, curUser);
                // Fire the Application Approved event
                WorkflowMediator.AppealServices.ApproveAppealApplication(WfInstanceId, args);
                return true;

            }
            catch (Exception ex)
            {
                if (ExceptionPolicy.HandleException(ex, "DAL"))
                    throw;
                return false;
            }
        }