public IHttpActionResult Pay()
{
var request = Context.AuthenticatedRequest;
var repository = new RecordRepository();
var siteId = request.GetPostInt("siteId");
var productId = request.GetPostString("productId");
var productName = request.GetPostString("productName");
var fee = request.GetPostDecimal("fee");
var channel = request.GetPostString("channel");
var message = request.GetPostString("message");
var isMobile = request.GetPostBool("isMobile");
var successUrl = request.GetPostString("successUrl");
var orderNo = Regex.Replace(Convert.ToBase64String(Guid.NewGuid().ToByteArray()), "[/+=]", "");
successUrl += "&orderNo=" + orderNo;
var paymentApi = new PaymentApi(siteId);
var recordInfo = new RecordInfo
{
SiteId = siteId,
Message = message,
ProductId = productId,
ProductName = productName,
Fee = fee,
OrderNo = orderNo,
Channel = channel,
IsPayed = false,
UserName = request.UserName,
AddDate = DateTime.Now
};
repository.Insert(recordInfo);
var redirectUrl = string.Empty;
var wxPayQrCodeUrl = string.Empty;
var wxPayOrderNo = string.Empty;
if (channel == "AliPay")
{
redirectUrl = paymentApi.ChargeByAliPay(productName, fee, orderNo, successUrl);
}
if (channel == "WxPay")
{
var apiUrl = Context.Environment.ApiUrl;
wxPayOrderNo = orderNo;
var notifyUrl = UrlUtils.GetWxPayNotifyUrl(apiUrl, wxPayOrderNo, siteId);
var url = HttpUtility.UrlEncode(paymentApi.ChargeByWxPay(productName, fee, orderNo, notifyUrl));
wxPayQrCodeUrl = UrlUtils.GetWxPayQrCodeUrl(apiUrl, url);
}
return(Ok(new
{
Value = redirectUrl,
WxPayQrCodeUrl = wxPayQrCodeUrl,
WxPayOrderNo = wxPayOrderNo
}));
}
public override void Startup(IService service)
{
RecordRepository = new RecordRepository();
service
.AddDatabaseTable(RecordRepository.TableName, RecordRepository.TableColumns)
.AddSiteMenu(siteId => new Menu
{
Text = "文章打赏",
IconClass = "ion-social-yen",
Menus = new List <Menu>
{
new Menu
{
Text = "文章打赏记录",
Href = "pages/records.html"
},
new Menu
{
Text = "文章打赏设置",
Href = "pages/settings.html"
}
}
})
.AddStlElementParser(StlReward.ElementName, StlReward.Parse);
//service.RestApiGet += Service_RestApiGet;
//service.RestApiPost += Service_RestApiPost;
}
public static HttpResponseMessage WxPayNotify()
{
var request = Context.AuthenticatedRequest;
var repository = new RecordRepository();
var siteId = request.GetQueryInt("siteId");
var orderNo = request.GetQueryString("orderNo");
var paymentApi = new PaymentApi(siteId);
paymentApi.NotifyByWxPay(HttpContext.Current.Request, out var isPayed, out var responseXml);
//var filePath = Path.Combine(Main.PhysicalApplicationPath, "log.txt");
//File.WriteAllText(filePath, responseXml);
if (isPayed)
{
repository.UpdateIsPayed(orderNo);
}
var response = new HttpResponseMessage {
Content = new StringContent(responseXml)
};
response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
response.StatusCode = HttpStatusCode.OK;
return(response);
}
public static RecordRepository GetRecordRepository()
{
var repository = new RecordRepository();
repository.UnitOfWork = GetUnitOfWork();
return(repository);
}
public static RecordRepository GetRecordRepository(IUnitOfWork unitOfWork)
{
var repository = new RecordRepository();
repository.UnitOfWork = unitOfWork;
return(repository);
}
public override void Startup(IService service)
{
PluginId = Id;
var repository = new RecordRepository();
service
.AddSiteMenu(siteId => new Menu
{
Text = "在线支付",
IconClass = "ion-card",
Menus = new List <Menu>
{
new Menu
{
Text = "在线支付记录",
Href = "pages/payment/records.html"
},
new Menu
{
Text = "在线支付设置",
Href = "pages/payment/settings.html"
}
}
})
.AddDatabaseTable(repository.TableName, repository.TableColumns)
.AddStlElementParser(StlPayment.ElementName, StlPayment.Parse);
//service.RestApiPost += Service_RestApiPost;
}
public FileResult Get(OaiVerb verb, string identifier = "", string metadataPrefix = "", string from = "", string until = "", string set = "", string resumptionToken = "")
{
//CONFIG OAI-PMH
_configOAI.BaseUrl = () =>
{
Uri baseUri = new Uri(_configOAI_PMH_CVN.GetConfigUrl());
return(baseUri.AbsoluteUri);
};
//MetadataFormatRepository
MetadataFormatRepository metadataFormatRepository = new MetadataFormatRepository();
RecordRepository recordRepository = new RecordRepository(_configOAI, _configOAI_PMH_CVN);
//SetRepository
SetRepository setRepository = new SetRepository(_configOAI);
DataProvider provider = new DataProvider(_configOAI, metadataFormatRepository, recordRepository, setRepository);
ArgumentContainer arguments = new ArgumentContainer(verb.ToString(), metadataPrefix, resumptionToken, identifier, from, until, set);
XDocument document = provider.ToXDocument(DateTime.Now.AddMinutes(100), arguments);
var memoryStream = new MemoryStream();
var xmlWriter = XmlWriter.Create(memoryStream);
document.WriteTo(xmlWriter);
xmlWriter.Flush();
byte[] array = memoryStream.ToArray();
return(File(array, "application/xml"));
}
protected void Application_Start()
{
Instance = this;
Console.WriteLine("Starting APP");
userRepository = new UserRepository(DefaultMongoDBConnection);
recordRepository = new RecordRepository(DefaultMongoDBConnection);
userController = new UserController();
}
public async Task GetRecordCountFromRepository()
{
RecordRepository recordRepository = new RecordRepository(_context);
var Result = recordRepository.GetCount();
Assert.Equal(Result, 1);
}
public UnitOfWork(DataContext context)
{
_dataContext = context;
Projects = new ProjectRepository(_dataContext);
Variables = new VariableRepository(_dataContext);
Records = new RecordRepository(_dataContext);
Notifications = new NotificationRepository(_dataContext);
Auth = new AuthRepository(_dataContext);
Endpoints = new EndpointRepository(_dataContext);
}
public void Test_AddNewUser()
{
RecordRepository recordRepository = RecordRepository.getInstance();
string username = "******";
recordRepository.AddUserToDictionary(username, new List <Record>());
bool status = recordRepository.getUserRecords().ContainsKey("username");
Assert.IsTrue(status);
}
public ConfigurationReader(string applicationName, string connectionString, int refreshTimerIntervalInMs)
{
ApplicationName = applicationName;
ConnectionString = connectionString;
RefreshTimerIntervalInMs = refreshTimerIntervalInMs;
this.RecordRepository = new RecordRepository(connectionString, "configuration", "records");
this.StartAsync(new CancellationToken());
}
public void Update()
{
// Arrange
var repository = new RecordRepository();
// Act
var result = repository.Update(null);
// Assert
Assert.IsNotNull(result);
}
public RecordUseCases(
ISubdivisionUseCases subdivisionUseCases,
ExhibitRepository exhibitRepository,
RecordRepository recordRepository,
INotificationUseCases notificationUseCases)
{
_subdivisionUseCases = subdivisionUseCases;
_exhibitRepository = exhibitRepository;
_recordRepository = recordRepository;
_notificationUseCases = notificationUseCases;
}
public void Delete()
{
// Arrange
var repository = new RecordRepository();
// Act
var result = repository.Delete(null);
// Assert
Assert.IsTrue(result);
}
public void FetchRecordList()
{
// Arrange
var repository = new RecordRepository();
// Act
var result = repository.FetchRecordList();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(15, result.Count());
}
private void GetRecords()
{
try
{
Records = RecordRepository.GetListByApplicationName(ApplicationName);
WriteToFile();
}
catch
{
ReadFromFile();
}
}
private async Task GetRecords()
{
try
{
Records = RecordRepository.GetListByApplicationName(ApplicationName);
WriteToFile();
}
catch (Exception ex)
{
ReadFromFile();
}
}
public override bool Save()
{
//TODO: Verify that this is right.
RecordRepository.Insert(this);
if (RecordRepository.Save() > 0)
{
return(true);
}
RecordRepository.Discard();
return(false);
}
public void Setup()
{
// Would normally create some mock objects. In this case
// the record repository pretty much already is a mock
// implementation of a repository anyway, i.e.,
// it doesn't really access a database.
//
var recordParser = new RecordParser();
var recordSorter = new RecordSorter();
var recordRepository = new RecordRepository(recordSorter);
_recordsController = new RecordsController(recordParser, recordRepository);
}
public IHttpActionResult WxPayInterval()
{
var request = Context.AuthenticatedRequest;
var repository = new RecordRepository();
var orderNo = request.GetQueryString("orderNo");
var isPayed = repository.IsPayed(orderNo);
return(Ok(new
{
Value = isPayed
}));
}
public IHttpActionResult PaySuccess()
{
var request = Context.AuthenticatedRequest;
var repository = new RecordRepository();
var orderNo = request.GetPostString("orderNo");
repository.UpdateIsPayed(orderNo);
return(Ok(new
{
Value = true
}));
}
private void AddRecordButton_Click(object sender, EventArgs e)
{
var recordRepository = new RecordRepository();
var subjectRepository = new SubjectRepository();
var mark = (int)subjectsNumeric.Value;
var studentId = _inspectingList.Last();
var expression = $"SubjectName = \'{subjectsComboBox.SelectedItem}\'";
var subjectId = (int)subjectRepository.FindAll().Select(expression)[0]["SubjectID"];
var record = new Record(mark, studentId, subjectId);
recordRepository.Create(record);
RefreshRecordsList(_inspectingList.Last());
}
public async void Add()
{
var target = new RecordRepository();
var record = new Models.Record
{
Id = Guid.NewGuid().ToString(),
Value = "This value was added programmatically!"
};
await target.Add(record);
var persistedRecord = await target.Get(record.Id);
Assert.Equal(JsonConvert.SerializeObject(record), JsonConvert.SerializeObject(persistedRecord));
await target.Delete(record.Id);
}
//public override bool IsValid()
//{
// return true;
//}
public override bool Save()
{
RecordRepository.Insert(this);
if (IsFixedAsset)
{
FixedAsset.Record = this;
FixedAssetRepository.Insert(FixedAsset);
}
if (RecordRepository.Save() > 0 || FixedAssetRepository.Save() > 0)
{
return(true);
}
RecordRepository.Discard();
return(false);
}
public List <Notification> GetNotifications()
{
var records = new RecordRepository().GetAllRecords(new FilterModel(), 99999, 0);
var notifications = new List <Notification>();
foreach (var record in records)
{
var notification = CreateNotificationForRecord(record);
if (notification != null)
{
notifications.Add(notification);
}
}
return(notifications);
}
public override bool Save()
{
RecordRepository.Insert(this);
if (BankBook != null)
{
BankBook.Record = this;
_bankBookRepository.Insert(BankBook);
}
if (RecordRepository.Save() > 0 || _bankBookRepository.Save() > 0)
{
return(true);
}
RecordRepository.Discard();
return(false);
}
private ActionResult GetMediaItemList(string classificationNamePathAppSettingsKey, string mediaType)
{
try
{
RecordRepository recordRepository = new RecordRepository((Application)Session["AdamApp"]);
string configClassificationPath = ConfigurationManager.AppSettings[classificationNamePathAppSettingsKey];
var recordCollection = recordRepository.GetRecordCollectionByClassificationNamePath(configClassificationPath);
MediaSetViewModel model = new MediaSetViewModel(recordCollection, mediaType);
return PartialView("_MediaListPartial", model);
}
catch (Exception)
{
((Application)Session["AdamApp"]).LogOff();
throw;
}
}
private void List()
{
Console.Clear();
List <Record> records = new List <Record>();
RecordRepository recordRepo = new RecordRepository();
records = recordRepo.GetAll(task.ID);
foreach (Record record in records)
{
Console.WriteLine("Working Hours: " + record.WorkingHours);
Console.WriteLine("Created Date: " + record.CreateDate);
}
Console.ReadKey(true);
}
public UnitOfWork(PatientManagementDbContext context)
{
_context = context;
Accounts = new AccountRepository(_context);
Categories = new CategoryRepository(_context);
DetailPrescriptions = new DetailPrescriptionRepository(_context);
Items = new ItemRepository(_context);
DetailRecords = new DetailRecordRepository(_context);
Medicines = new MedicineRepository(_context);
Patients = new PatientRepository(_context);
MedicalSupplies = new MedicalSupplyRepository(_context);
Prescriptions = new PrescriptionRepository(_context);
Records = new RecordRepository(_context);
AttachmentAssigns = new AttachmentAssignRepository(_context);
Attachments = new AttachmentRepository(_context);
Doctors = new DoctorRepository(_context);
Faculties = new FacultyRepository(_context);
}
public IHttpActionResult Delete()
{
try
{
var request = Context.AuthenticatedRequest;
var recordRepository = new RecordRepository();
var siteId = request.GetQueryInt("siteId");
var page = request.GetQueryInt("page", 1);
var recordId = request.GetQueryInt("recordId", 1);
const int perPage = 30;
if (!request.IsAdminLoggin || !request.AdminPermissions.HasSitePermissions(siteId, Main.PluginId))
{
return(Unauthorized());
}
recordRepository.Delete(recordId);
var totalCount = recordRepository.GetPayedCount(siteId);
var pages = Convert.ToInt32(Math.Ceiling((double)totalCount / perPage));
if (pages == 0)
{
pages = 1;
}
if (page > pages)
{
page = pages;
}
var recordInfoList = recordRepository.GetPayedRecordInfoList(siteId, page, perPage);
return(Ok(new
{
Value = recordInfoList,
Count = totalCount,
Pages = pages,
Page = page
}));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public ActionResult GetVideoFileStream(Guid videoRecordId)
{
try
{
RecordRepository recordRepository = new RecordRepository((Application)Session["AdamApp"]);
string path = recordRepository.Get(videoRecordId).Files.LatestMaster.Path;
//74bdf7e4-6fb7-4153-94d9-a54700f71604
FileWebRequest request = (FileWebRequest)WebRequest.Create(path);
request.Method = WebRequestMethods.Ftp.DownloadFile;
FileWebResponse response = (FileWebResponse)request.GetResponse();
using (Stream responseStream = response.GetResponseStream())
{
byte[] fileBytes = new byte[responseStream.Length];
responseStream.Read(fileBytes, 0, fileBytes.Length);
return new FileContentResult(fileBytes, "video/mp4");//File(responseStream, "video/mp4");
}
}
catch (Exception)
{
((Application)Session["AdamApp"]).LogOff();
throw;
}
}
public static RecordRepository GetRecordRepository()
{
var repository = new RecordRepository();
repository.UnitOfWork = GetUnitOfWork();
return repository;
}
public static RecordRepository GetRecordRepository(IUnitOfWork unitOfWork)
{
var repository = new RecordRepository();
repository.UnitOfWork = unitOfWork;
return repository;
}
public FileContentResult GetRecordMasterPreview(Guid recordId)
{
try
{
RecordRepository recordRepository = new RecordRepository((Application)Session["AdamApp"]);
byte[] previewFileBytes = recordRepository.Get(recordId).Files.LatestMaster.GetPreview().GetBytes();
if (previewFileBytes==null)
{
using (FileStream stream = System.IO.File.OpenRead("/Content/images/movie_prev.png"))
{
previewFileBytes = new byte[stream.Length];
stream.Read(previewFileBytes, 0, previewFileBytes.Length);
}
}
return new FileContentResult(previewFileBytes, "image/jpeg");
}
catch (Exception ex)
{
((Application)Session["AdamApp"]).LogOff();
throw;
}
}
public ActionResult GetMediaItemInfo(Guid mediaRecId)
{
RecordRepository recordRepository = new RecordRepository((Application)Session["AdamApp"]);
MediaViewModel model = new MediaViewModel(recordRepository.Get(mediaRecId));
return PartialView("_MediaModelPartial", model);
}
public ContentResult GenerateVideoTag(Guid videoRecordId, string createdTagId)
{
try
{
RecordRepository recordRepository = new RecordRepository((Application)Session["AdamApp"]);
string path = recordRepository.Get(videoRecordId).Files.LatestMaster.Path;
TagBuilder videoTag = new TagBuilder("video");
videoTag.Attributes.Add("id", createdTagId);
videoTag.Attributes.Add("width", "50%");
videoTag.Attributes.Add("height", "auto");
videoTag.Attributes.Add("loop", "true");
videoTag.Attributes.Add("controls", "controls");
videoTag.Attributes.Add("style", "min-height:50px;");
TagBuilder sourceTag = new TagBuilder("source");
UrlHelper urlHelper = new UrlHelper(HttpContext.Request.RequestContext);
string url = urlHelper.Action("GetVideoFileStream", "Home", new { videoRecordId = videoRecordId });
sourceTag.Attributes.Add("src", url);
sourceTag.Attributes.Add("type", @"video/mp4");
sourceTag.Attributes.Add("codecs", "avc1.42E01E, mp4a.40.2");
videoTag.InnerHtml += sourceTag;
return Content(videoTag.ToString());
}
catch (Exception)
{
((Application)Session["AdamApp"]).LogOff();
throw;
}
}
