public void createUserList(CoreService.MList categoryitem, CoreService.MList[] subcategoryitems, string userid)
{
//Importing CategoryItem into Users App List
try
{
appclient.Createlist(categoryitem.Id, categoryitem.Title, categoryitem.Type, userid, "00000000000000000000000000000000", "00000000000000000000000000000000", userid, "", categoryitem.ObjectType, categoryitem.Indexval, "", "");
}
catch { }
//Retriving Newly Created Category List Item
ApplicationService.list1[] newcatglist = appclient.Getlists(categoryitem.Id, "1", "100");
//Importing Sub CaegoryItems into User App List
foreach (CoreService.MList subitem in subcategoryitems)
{
try
{
appclient.Createlist(subitem.Id, subitem.Title, subitem.Type, newcatglist[0].listid, "00000000000000000000000000000000", "00000000000000000000000000000000", userid, "", subitem.ObjectType, subitem.Indexval, "", "");
}
catch
{
}
}
}
private void InitEventHandler()
{
Shown += async(sender, e) =>
{
SearchBox.Focus();
var sentences = await CoreService.GetAllSentence();
MainListView.BeginUpdate();
MainListView.Items.Clear();
MainListView.Items.AddRange(Helper.ConvertSentenceToListViewItem(sentences));
MainListView.EndUpdate();
TotalCountLabel.Text = $@"Total {MainListView.Items.Count} Sentences";
};
SearchBox.TextChanged += async(sender, e) =>
{
var box = sender as TextBox;
IEnumerable <Sentence> sentences;
if (box?.Text.Length >= 1)
{
sentences = await CoreService.SearchBySentence(box.Text, Configuration.GetKeywordMaxLength());
}
else
{
sentences = await CoreService.GetAllSentence();
}
var sentenceList = sentences as IList <Sentence> ?? sentences.ToList();
MainListView.BeginUpdate();
MainListView.Items.Clear();
MainListView.Items.AddRange(Helper.ConvertSentenceToListViewItem(sentenceList));
MainListView.EndUpdate();
TotalCountLabel.Text = $@"Total {MainListView.Items.Count} Sentences";
};
MainListView.SelectedIndexChanged += (sender, e) =>
{
_listViewFoucsed = true;
var listView = sender as ListView;
if (listView == null)
{
return;
}
if (listView.SelectedIndices.Count == 0)
{
return;
}
var index = listView.SelectedIndices[0];
var toCopy = MainListView.Items[index].SubItems[1];
_listViewSelectedRowOffset = index;
Clipboard.SetText(toCopy.Text);
SentenceLabel.Text = toCopy.Text;
StatusLabel.Text = Constant.Copyed;
};
SizeChanged += (sender, e) =>
{
MainListView.Columns[1].Width = Size.Width - MainListView.Columns[0].Width - MainListView.Columns[2].Width - 20;
};
}
static void Main(string[] args)
{
//Set managers
ManagerBase2.SetTraceLog(generaltracelog);
CoreService.SetTraceLog(generaltracelog);
//GET THE ASSEMBLY'S DIRECTORY
string file = System.Reflection.Assembly.GetExecutingAssembly().Location;
string fname = Path.GetFileNameWithoutExtension(file);
//TRACELOG
Trace.AutoFlush = true;
Trace.IndentSize = 4;
if (System.Diagnostics.Trace.Listeners.Count <= 1 && (System.Diagnostics.Trace.Listeners["Default"] == null ||
System.Diagnostics.Trace.Listeners["Default"].GetType() == typeof(System.Diagnostics.DefaultTraceListener)))
{
DelimitedListTraceListener del = new System.Diagnostics.DelimitedListTraceListener((fname + ".log.csv"), "text");
del.Delimiter = ",";
System.Diagnostics.Trace.Listeners.Add(del);
}
Trace.WriteLine("#############################################################################");
Trace.WriteLine(string.Format("Saga Map Server starting on: {0}", DateTime.Now));
Trace.WriteLine(string.Format("OS Information: {0}", Environment.OSVersion));
Trace.WriteLine(string.Format("Number of Processors: {0}", Environment.ProcessorCount));
Trace.WriteLine(string.Format("CLR Version: {0}", Environment.Version));
Trace.WriteLine(string.Format("Working set: {0}", Environment.WorkingSet));
Trace.WriteLine(string.Format("OS Bit Version: {0} Bit", IntPtr.Size * 8));
Trace.WriteLine("#############################################################################");
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
//Do initial configuration
FirstRunConfiguration();
_ConsoleCommands = ManagerBase2.ProvideManager <ConsoleCommands>("Saga.Manager.ConsoleSettings");
_NetworkService = ManagerBase2.ProvideManager <NetworkService>("Saga.Manager.NetworkSettings");
_WorldTasks = ManagerBase2.ProvideManager <WorldTasks>("Saga.Manager.WorldTasks");
_Database = ManagerBase2.ProvideManager <Database>("Saga.Manager.Database");
_Quests = ManagerBase2.ProvideManager <Saga.Managers.Quests>("Saga.Manager.Quest");
_ScriptCompiler = ManagerBase2.ProvideManager <ScriptCompiler>("Saga.Manager.Scripting");
_EventManager = FactoryBase.ProvideManager <EventManager>("Saga.Factory.Events");
_Additions = FactoryBase.ProvideManager <Additions>("Saga.Factory.Addition");
_Portals = FactoryBase.ProvideManager <Portals>("Saga.Factory.Portals");
_Spells = FactoryBase.ProvideManager <Saga.Factory.Spells>("Saga.Factory.Spells");
_StatusByLevel = FactoryBase.ProvideManager <Saga.Factory.StatusByLevel>("Saga.Factory.StatusByLevel");
_Warps = FactoryBase.ProvideManager <Warps>("Saga.Factory.Warps");
_Zones = FactoryBase.ProvideManager <Zones>("Saga.Factory.Zones");
_ItemFactory = FactoryBase.ProvideManager <ItemsFactory>("Saga.Factory.Items");
_Weaponary = FactoryBase.ProvideManager <Weaponary>("Saga.Factory.Weaponary");
_SpawnTemplates = FactoryBase.ProvideManager <SpawnTemplate>("Saga.Factory.SpawnTemplate");
_SpawnWorldObjects = FactoryBase.ProvideManager <SpawnWorldObjects>("Saga.Factory.SpawnWorldObjects");
_SpawnMultiWorldObjectSettings = FactoryBase.ProvideManager <SpawnMultiWorldObjects>("Saga.Factory.SpawnMultiWorldObjects");
_CharacterConfiguration = FactoryBase.ProvideManager <CharacterConfiguration>("Saga.Factory.CharacterConfiguration");
_ItemDrops = FactoryBase.ProvideManager <ItemsDrops>("Saga.Factory.ItemDrops");
try
{
ManagerCollection section = (ManagerCollection)ConfigurationManager.GetSection("Saga.Managers");
if (section != null)
{
foreach (SingletonManagerElement element in section)
{
ManagerBase2 managerBase = ManagerBase2.ProvideManagerFromTypeString <ManagerBase2>(element.Type);
_CustomManagers.Add(element.Name, managerBase);
}
}
}
catch (Exception e)
{
HostContext.Current.AddUnhandeldException(e);
}
finally
{
HostContext.Current.Initialize();
HostContext.Current.BeforeQuerySettings();
HostContext.Current.AfterQuerySettings();
HostContext.Current.Load();
HostContext.Current.Loaded();
}
Console.ReadLine();
}
public static void BasicSetup(TestContext context)
{
//第一步
myCoreService = CoreService.GetInstance();
myCoreService.Init("mongodb://127.0.0.1:27017", "JDBC-test", "Experiment");
}
public SwitchModel(ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public IActionResult Facility(string code, FacilityViewModel model, CoreService service)
{
model.Facility = service.GetFacility(code);
return(View(model));
}
public SuggestionRegectModel(VetCoin.Data.ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public RegularDistributeModel(CoreService coreService)
{
CoreService = coreService;
}
public MarkdownEditModel(VetCoin.Data.ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public PessoaController(CoreService coreService)
{
this._core = coreService;
}
public Tests()
{
cs = new CoreService();
}
public EnderecoController(CoreService coreService)
{
this._core = coreService;
}
public async Task <IActionResult> OnGetAsync()
{
UserContext = CoreService.GetUserContext();
if (UserContext == null)
{
return(NotFound());
}
VetMember = UserContext.CurrentUser;
Transactions = CoreService
.GetCoinTransactionQuery(UserContext.CurrentUser)
.Include(c => c.RecivedVetMember)
.Include(c => c.SendVetMember)
.OrderByDescending(c => c.CreateDate)
.Take(5);
Trades = CoreService.DbContext
.Trades
.Include(c => c.VetMember)
.Include(c => c.TradeMessages)
.ThenInclude(c => c.VetMember)
.OrderByDescending(c => c.CreateDate)
.Where(c => c.VetMemberId == UserContext.CurrentUser.Id)
.Take(5)
.ToArray();
CommentedTrades = CoreService.DbContext
.Trades
.Include(c => c.VetMember)
.Include(c => c.TradeMessages)
.ThenInclude(c => c.VetMember)
.OrderByDescending(c => c.TradeMessages.Max(d => d.CreateDate))
.Where(c =>
c.TradeMessages.Any(d => d.VetMemberId == UserContext.CurrentUser.Id) &&
c.VetMemberId != UserContext.CurrentUser.Id
)
.Take(5)
.ToArray();
Contracts = await CoreService.DbContext
.Contracts
.Include(c => c.VetMember)
.Include(c => c.Trade.VetMember)
.Where(c => c.VetMemberId == UserContext.CurrentUser.Id)
.OrderByDescending(c => c.ContractMessages.Max(d => d.CreateDate))
.Take(5)
.ToArrayAsync();
Venders = await CoreService.DbContext
.Venders
.Include(c => c.VetMember)
.Where(c => c.VetMemberId == UserContext.CurrentUser.Id)
.OrderByDescending(c => c.CreateDate)
.Take(5)
.ToArrayAsync();
WaitingContracts = await CoreService.EnumWaitingContracts(VetMember);
return(Page());
}
public IndexModel(CoreService coreService)
{
CoreService = coreService;
}
public void SignedTransaction_Transaction()
{
var xmlpath = PathFor("SignedTransaction.xml");
_service = new CoreService("", "", "RKOCG5D8D3fZxDSg504D0IxU2XD4Io5VXmyzdCtTivHFTTSylzM2ZzTWFwVH4ucG", "");
var transaction = _service.Deserialize<Transaction>(File.ReadAllText(xmlpath));
var actual = _service.ValidateTransactionSignature(transaction);
Assert.IsTrue(actual);
}
public ContractAgreementModel(VetCoin.Data.ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public IndexModel(ILogger <IndexModel> logger, CoreService coreService)
{
_logger = logger;
CoreService = coreService;
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
//DbContext.Attach(Contract).State = EntityState.Modified;
var entity = DbContext.Contracts
.Include(c => c.VetMember)
.FirstOrDefault(c => c.Id == Contract.Id);
var trade = DbContext.Trades
.Include(c => c.VetMember)
.FirstOrDefault(c => c.Id == entity.TradeId);
//await TryUpdateModelAsync(entity, nameof(Contract));
//TODO:契約を結ぶためのコード
var escrowUser = DbContext.VetMembers.First(c => c.MemberType == MemberType.Escrow);
var escrowSendUser = trade.Direction == Direction.Buy ?
DbContext.VetMembers.Find(trade.VetMemberId) :
DbContext.VetMembers.Find(entity.VetMemberId);
var restAmmount = CoreService.CalcAmount(escrowSendUser);
if (restAmmount < entity.Reword)
{
IsInsufficientFunds = true;
return(await OnGetAsync(Contract.Id));
}
entity.ContractStatus = ContractStatus.Working;
entity.EscrowTransaction = new CoinTransaction
{
RecivedVetMemberId = escrowUser.Id,
Amount = entity.Reword,
SendeVetMemberId = escrowSendUser.Id,
Text = $"{trade.Title } 代金 {entity.Reword}VEC",
TransactionType = CoinTransactionType.Contract
};
try
{
await DbContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ContractExists(Contract.Id))
{
return(NotFound());
}
else
{
throw;
}
}
await SendMessages(entity, trade.VetMember, entity.VetMember);
return(RedirectToPage("./Index", new { contractId = Contract.Id }));
}
public CreateModel(ApplicationDbContext context, CoreService coreService, DiscordService discordService)
{
DbContext = context;
CoreService = coreService;
}
public ContractCompleteModel(VetCoin.Data.ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public SendModel(CoreService coreService)
{
CoreService = coreService;
}
public async Task PostSuperChat(ISocketMessageChannel channel, ulong fromId, ulong toId, int amount, string message, IDMChannel fromDmChannel, IDMChannel toDmChannel)
{
var fromMember = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == fromId);
if (fromMember == null)
{
await fromDmChannel.SendMessageAsync("VetCoin 登録者以外はSuperChatを送信できません");
return;
}
var fromAmount = CoreService.CalcAmount(fromMember);
if (fromAmount < amount)
{
await fromDmChannel.SendMessageAsync($"{StaticSettings.CurrenryUnit}残高が不足しています。({fromAmount}{StaticSettings.CurrenryUnit})");
return;
}
if (amount < StaticSettings.SuperChatLowLimit)
{
await fromDmChannel.SendMessageAsync($"送金下限は{StaticSettings.SuperChatLowLimit}{StaticSettings.CurrenryUnit}です。それ未満は送れません");
return;
}
if (amount > StaticSettings.SuperChatHeightLimit)
{
await fromDmChannel.SendMessageAsync($"送金上限は{StaticSettings.SuperChatHeightLimit}{StaticSettings.CurrenryUnit}です。それ以上は送れません");
return;
}
var toMember = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == toId);
if (toMember == null)
{
await fromDmChannel.SendMessageAsync("VetCoin 登録者以外へはSuperChatを送信できません");
return;
//toMember = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == 287434171570192384);
}
var toAmount = CoreService.CalcAmount(toMember);
if (toMember.Id == fromMember.Id)
{ //念のため同一人物の対応
toAmount -= amount;
fromAmount += amount;
}
try
{
if (fromDmChannel != null)
{
await fromDmChannel.SendMessageAsync($@"SuperChat:{toMember.Name}へ{amount}{StaticSettings.CurrenryUnit} 送金しました [{fromAmount - amount}{StaticSettings.CurrenryUnit}]");
}
if (toDmChannel != null)
{
await toDmChannel.SendMessageAsync($@"SuperChat:{fromMember.Name}から{amount}{StaticSettings.CurrenryUnit} をもらいました [{toAmount + amount}{StaticSettings.CurrenryUnit}]");
}
DbContext.CoinTransactions.Add(new CoinTransaction
{
SendeVetMemberId = fromMember.Id,
Amount = amount,
RecivedVetMemberId = toMember.Id,
Text = message,
TransactionType = CoinTransactionType.SuperChat,
});
await DbContext.SaveChangesAsync();
}
catch
{
await fromDmChannel.SendMessageAsync("システムトラブルの可能性があります。開発者に問い合わせをお願いします。");
return;
}
try
{
var imageMs = await CreateImage(fromMember, toMember, amount);
await channel.SendFileAsync(imageMs, $"Send{amount}.png", message);
}
catch
{
await fromDmChannel.SendMessageAsync("システムトラブルの可能性があります。開発者に問い合わせをお願いします。(送金は成功しています)");
}
}
public VenderLikeVotesController(ApplicationDbContext context, CoreService coreService)
{
_context = context;
CoreService = coreService;
}
public async Task SendCoin(ulong fromId, ulong toId, int amount, IDMChannel fromDmChannel, IDMChannel toDmChannel, string jumpUrl)
{
var fromMember = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == fromId);
if (fromMember == null)
{
await fromDmChannel.SendMessageAsync($"{StaticSettings.SiteTitle} 登録者以外は送信できません");
return;
}
var fromAmount = CoreService.CalcAmount(fromMember);
if (fromAmount < amount)
{
await fromDmChannel.SendMessageAsync($"{StaticSettings.CurrenryUnit}残高が不足しています。({fromAmount}{StaticSettings.CurrenryUnit})");
return;
}
var toMember = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == toId);
if (toMember == null)
{
await fromDmChannel.SendMessageAsync($"{StaticSettings.SiteTitle} 登録者以外へは送信できません");
return;
//toMember = DbContext.VetMembers.FirstOrDefault(c => c.DiscordId == 287434171570192384);
}
var toAmount = CoreService.CalcAmount(toMember);
if (toMember.Id == fromMember.Id)
{ //念のため同一人物の対応
toAmount -= amount;
fromAmount += amount;
}
try
{
DbContext.CoinTransactions.Add(new CoinTransaction
{
SendeVetMemberId = fromMember.Id,
Amount = amount,
RecivedVetMemberId = toMember.Id,
Text = "リアクション送金",
TransactionType = CoinTransactionType.ReactionSend,
});
await DbContext.SaveChangesAsync();
if (fromDmChannel != null)
{
await fromDmChannel.SendMessageAsync($@"Reaction:{toMember.Name} へ {amount} {StaticSettings.CurrenryUnit} を送金しました[{fromAmount - amount}vec]");
}
await toDmChannel.SendMessageAsync($@"Reaction: {fromMember.Name} から {amount} {StaticSettings.CurrenryUnit} をもらいました[{toAmount + amount}vec]
{jumpUrl}");
}
catch
{
await fromDmChannel.SendMessageAsync("システムトラブルの可能性があります。開発者に問い合わせをお願いします。");
return;
}
}
public IActionResult FinanceStationWise(int month, int year, FinanceStationwiseViewModel model, CoreService service)
{
model.Date = new DateTime(year, month, 1);
model.Income = service.GetManagementIncomePerStation(model.Date, model.Date.AddMonths(1).AddDays(-1));
model.Costs = service.GetManagementCostsPerStation(model.Date, model.Date.AddMonths(1).AddDays(-1));
return(View(model));
}
public void Dispose()
{
_service = null;
}
public void UpdateLatestPurchasePrice()
{
Price = new CoreService().GetLatestPurchasePrice();
}
public DetailsModel(ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public IndexModel(VetCoin.Data.ApplicationDbContext context, CoreService coreService)
{
DbContext = context;
CoreService = coreService;
}
public async Task <ActionResult <PutResult> > PutExteralApplicationPayment(Guid id, string discordId)
{
var discordIdul = ulong.Parse(discordId);
var exteralApplicationPayment = await _context.ExteralApplicationPayments
.Include(c => c.ExteralApplication)
.AsQueryable()
.FirstOrDefaultAsync(c => c.Id == id && c.DiscordId == discordIdul);
if (exteralApplicationPayment == null)
{
return(NotFound());
}
if (exteralApplicationPayment.ExpirationDate <= DateTimeOffset.Now)
{
return(new PutResult
{
IsSucceed = false,
ErrorMessage = "有効期限切れ"
});
}
if (exteralApplicationPayment.IsPayd)
{
return(new PutResult
{
IsSucceed = false,
ErrorMessage = "支払い済みのデータです"
});
}
//TODO:トランザクションを作る
var venderId = exteralApplicationPayment.ExteralApplication.VetMemberId;
var buyMember = await _context.VetMembers.AsQueryable().FirstOrDefaultAsync(c => c.DiscordId == discordIdul);
var lestAmount = CoreService.CalcAmount(buyMember);
if (lestAmount < exteralApplicationPayment.Amount)
{
return(new PutResult
{
IsSucceed = false,
ErrorMessage = "残高不足"
});
}
var transaction = new CoinTransaction
{
SendeVetMemberId = buyMember.Id,
RecivedVetMemberId = venderId,
Amount = exteralApplicationPayment.Amount,
Text = $"外部購入:{exteralApplicationPayment.ExteralApplication.Name}:{exteralApplicationPayment.Id}",
};
exteralApplicationPayment.IsPayd = true;
_context.CoinTransactions.Add(transaction);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExteralApplicationPaymentExists(id))
{
return(new PutResult
{
IsSucceed = false,
ErrorMessage = "DB書き込みに失敗しました。",
});
}
else
{
throw;
}
}
return(new PutResult
{
IsSucceed = true,
});
}
public void Setup()
{
_service = new CoreService("", "", "", "");
}
public IActionResult Index(FacilityViewModel model, CoreService service)
{
model.Facilities = service.GetFacilities();
return(View(model));
}
public void SignedTransaction_Xml()
{
var transactionXml = File.ReadAllText(PathFor("SignedTransaction.xml"));
_service = new CoreService("", "", "RKOCG5D8D3fZxDSg504D0IxU2XD4Io5VXmyzdCtTivHFTTSylzM2ZzTWFwVH4ucG", "");
var result = _service.ValidateTransactionSignature(transactionXml);
Assert.IsTrue(result);
}
public MemberModel(CoreService coreService)
{
CoreService = coreService;
}
