public async Task <DbStatusResult> DeletePackages(int PrankId)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].DeletePackages",
                                       new SqlParameter("@PackageId", PrankId),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> DeleteInsuranseContractDetail(int id)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].spDeleteInsuranseContract",
                                       new SqlParameter("@contractId", id),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> AddPackageOrderInfo(PackageOrderModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].AddPackageOrderInfo",
                                       GetJsonParam("@PackageOrderInfo", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> UpdateInsuranseContractDetail(ContractEntityModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].[spUpdateContractInfo]",
                                       GetJsonParam("@contractInfo", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 5
0
        public async Task <DbStatusResult> UpdatePageContent(PageContentModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].UpdatePageContent",
                                       GetJsonParam("@PageContent", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> AddContactUsRequest(ContactUsEmailTrackModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].AddContactUsRequest",
                                       GetJsonParam("@ContactUsEmailTrack", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 7
0
        public async Task <DbStatusResult> UpdatePrankCallFromPhoneNumber(PrankCallFromPhoneNumberModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].UpdatePrankCallFromPhoneNumber",
                                       GetJsonParam("@PrankCallFromPhoneNumber", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 8
0
        public async Task <DbStatusResult> ValidateDeviceInfoRequest(DeviceInfoModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].ValidateDeviceInfoRequest",
                                       GetJsonParam("@DeviceInfo", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> AddReferralInviteInfo(ReferralInviteInfoModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].AddReferralInvitee",
                                       GetJsonParam("@ReferralInvitee", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 10
0
        public async Task <DbStatusResult> DeletePrankCallFromPhoneNumber(int prankCallFromId)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].DeletePrankCallFromPhoneNumber",
                                       new SqlParameter("@PrankCallFromId", prankCallFromId),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 11
0
        public async Task <DbStatusResult> DeleteCallHistory(int trackingId)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].DeleteCallHistory",
                                       new SqlParameter("@TrackingId", trackingId),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 12
0
        public async Task <DbStatusResult> AddPrankCallTracking(PrankCallTrackingModel entity)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].AddPrankCallTracking",
                                       GetJsonParam("@PrankCallTrackingInfo", entity),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> DeleteReferralInfo(int ReferralId)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].DeleteReferralInfo",
                                       new SqlParameter("@ReferralId", ReferralId),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 14
0
        public async Task <DbStatusResult> UpdateIsDefaultStatusFromPhoneNumber(int PrankCallFromId, bool IsDefault)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].UpdateIsDefaultStatusFromPhoneNumber",
                                       new SqlParameter("@PrankCallFromId", PrankCallFromId),
                                       new SqlParameter("@IsDefault", IsDefault),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
Esempio n. 15
0
        public async Task <DbStatusResult> UpdateStatusDeviceInfo(int deviceId, bool isActive)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].UpdateStatusDeviceInfo",
                                       new SqlParameter("@DeviceId", deviceId),
                                       new SqlParameter("@IsActive", isActive),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> UpdateReferralInviteInfo(int deviceId, int referralInviteId, string referralLinkKey)
        {
            var cmd = new DbStatusCommand();

            await ExecuteSQLWithParams("[dbo].UpdateReferralInviteeCallback",
                                       new SqlParameter("@DeviceId", deviceId),
                                       new SqlParameter("@ReferralInviteId", referralInviteId),
                                       new SqlParameter("@ReferralLinkKey", referralLinkKey),
                                       cmd.IdParam,
                                       cmd.StatusParam,
                                       cmd.MessageParam);

            return(cmd.StatusResult);
        }
        public async Task <DbStatusResult> UpdatePrankReferralInfo(ReferralInfoModel entity)
        {
            try
            {
                var cmd = new DbStatusCommand();

                await ExecuteSQLWithParams("[dbo].UpdatePrankReferralInfo",
                                           GetJsonParam("@ReferralInfo", entity),
                                           cmd.IdParam,
                                           cmd.StatusParam,
                                           cmd.MessageParam);

                return(cmd.StatusResult);
            }
            catch (Exception er)
            {
                throw;
            }
        }