public void Fatal(object message)
{
if (!_hasLoggedException)
{
_log.Fatal(DiagnosticReport.Generate(DiagnosticReportType.Full));
}
_log.Fatal(message);
_hasLoggedException = true;
}
public static async void StartBot(Core.OctoBot bot, bool useCatch = false)
{
ILoggingService loggingService = Application.Resolve <ILoggingService>();
try
{
// Запуск
await bot.Initialize();
await bot.Start();
Debug.WriteLine(1);
}
catch (Exception exc)
{
loggingService.Fatal($"OctoBot Exception : {exc.Message}");
if (useCatch == false)
{
throw new Exception(exc.Message);
}
Commands.StopBot(bot);
}
}
private static void Main(string[] args)
{
Bootstrapper.Register();
mStopwatch = new Stopwatch();
mLoggingService = TinyIoCContainer.Current.Resolve <ILoggingService>();
mPriceUpdaters = TinyIoCContainer.Current.ResolveAll <IPriceUpdater>().ToList();
// Setup worker
mUpdaterBackgroundWorker = new BackgroundWorker();
mUpdaterBackgroundWorker.WorkerReportsProgress = true;
mUpdaterBackgroundWorker.WorkerSupportsCancellation = true;
mUpdaterBackgroundWorker.DoWork += new DoWorkEventHandler(bw_UpdaterDoWork);
mUpdaterBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_EchoMtgsCompleted);
mUpdaterBackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(bw_EchoMtgProgressChanged);
try
{
Console.WriteLine("Running worker thread for EchoMtg...");
mUpdaterBackgroundWorker.RunWorkerAsync();
}
catch (Exception er)
{
string msg = string.Format("Error: {0}", er.Message);
mLoggingService.Fatal(er, msg);
Console.WriteLine(msg);
}
while (mUpdaterBackgroundWorker.IsBusy)
{
Thread.Sleep(100);
}
}
public void Fatal(Exception ex, string displayMessage = null)
{
LoopThroughInnerExceptions(ex, str => _loggingService.Fatal(str));
string errorMessage = displayMessage ?? "An unexpected error occurred. The application will now shut down.";
MessageBox.Show(errorMessage, "Fatal Application Error");
Application.Current.Shutdown();
}
public virtual void LogFatal(string message, int logMessageType = UNKNOWNLOGMESSAGETYPE,
[CallerMemberName] string methodName = "",
[CallerFilePath] string sourceFile = "",
[CallerLineNumber] int lineNumber = 0)
{
_log.Fatal(message: message, logMessageType: logMessageType,
methodName: methodName,
sourceFile: sourceFile,
lineNumber: lineNumber);
}
public async Task <BingoInstance> CreateNewBingoInstance(Guid meetingId)
{
Guid instanceId = Guid.NewGuid();
var newInstance = new ModelData.BB.BingoInstance()
{
BingoInstanceId = instanceId,
BingoInstanceStatusTypeId = (int)Constants.Enums.BingoInstanceStatusType.Active,
CreatedDate = DateTime.UtcNow,
CreatedUserId = _stateService.GetCurrentUserId(),
IncludeFreeSquareIndicator = true,
IsDeleted = false,
MeetingId = meetingId,
NumberOfColumns = 5,
NumberOfRows = 5,
UpdatedDate = DateTime.UtcNow,
UpdatedUserId = _stateService.GetCurrentUserId()
};
if (1 != await _asyncConnection.InsertAsync(newInstance))
{
var message = "Error Writing new meeting instance to SQLite";
_log.Fatal(message, LogMessageType.Instance.Exception_Database);
throw new Exception(message);
}
//queue the instance for upload
await DataUploadService.Instance.QueueAsync(instanceId, Constants.Enums.QueueableObjects.BingoInstance);
//create the new bingo instance content records, they will be queued for upload with the instance
await CreateNewBingoInstanceContentsNoRepeats(newInstance.BingoInstanceId);
//fire off safely backgrounded upload for the instance record and the content
DataUploadService.Instance.StartSafeQueuedUpdates();
return(newInstance.ToModelObj());
}
public static void Fatal(object message)
{
Service.Fatal(message);
}
/// <summary>
/// Runs all kernel events in the list
/// </summary>
/// <param name="kernelList">A list of kernel events</param>
private void RunKernelEvents(IEnumerable <IKernelEvent> kernelList)
{
// Loop through all kernal events
foreach (var kernelEvent in kernelList)
{
loggingService.Debug("Executing kernel event [{0}]", kernelEvent.DisplayName);
KernelEventCompletedArguments kernelEventArguments = null;
Exception kernelEventException = null;
try
{
kernelEventArguments = kernelEvent.Execute();
}
catch (Exception ex)
{
kernelEventException = ex;
}
if (kernelEventException != null)
{
// We got an exception during kernel event time, log this issue with Critical
var bootIssue = new GenericError
{
ErrorException = kernelEventException,
ErrorMessage = kernelEventException.ToString(),
Severity = ErrorSeverity.Critical
};
loggingService.Fatal(bootIssue);
throw new KernelEventIncompleteException(kernelEventException);
}
// Check if the kernel event returned a value
if (kernelEventArguments == null)
{
kernelEventArguments = new KernelEventCompletedArguments
{
KernelEventSucceeded = false,
AllowContinue = false,
Issues = new List <IError>
{
new GenericError
{
ErrorException = null,
ErrorMessage = "",
Severity = ErrorSeverity.Critical
}
}.ToArray()
}
}
;
if (!kernelEventArguments.KernelEventSucceeded) // Kernel event didn't succeed, log error
{
loggingService.Fatal(kernelEventArguments.Issues.ToArray());
}
if (!kernelEventArguments.AllowContinue) // If we're not allowed to continue, throw exception to stop execution
{
throw new KernelEventIncompleteException();
}
}
}
#endregion "Kernel events"
}
public void Fatal(object message, Exception exception)
{
_log.Fatal(message, exception);
}
static void Main(string[] args)
{
Bootstrapper.Register();
var p = new FluentCommandLineParser();
string inputName = null;
// Parse command line arguments
bool isMtgDbInfo = false;
string mtgDbInfoSet = null;
bool isMtgJson = false;
string mtgJsonFilename = null;
bool skipTokens = true;
string mtgJsonDirectory = null;
bool importByFile = true;
try
{
mStopwatch = Stopwatch.StartNew();
mLoggingService = TinyIoCContainer.Current.Resolve <ILoggingService>();
mMtgStore = TinyIoCContainer.Current.Resolve <IMtgStore>();
mFileSystem = TinyIoCContainer.Current.Resolve <IFileSystem>();
mImporter = TinyIoCContainer.Current.Resolve <IImporter>();
p.Setup <string>("set")
.Callback(value => mtgDbInfoSet = value)
.Required();
p.Setup <bool>("mtgjson")
.Callback(value => isMtgJson = value)
.SetDefault(true);
p.Setup <string>("file")
.Callback(value => mtgJsonFilename = value);
p.Setup <string>("dir")
.Callback(value => mtgJsonDirectory = value);
p.Setup <bool>("skiptokens")
.Callback(value => skipTokens = value)
.SetDefault(true);
p.Setup <bool>("skippromos")
.Callback(value => mSkipPromos = value)
.SetDefault(true);
p.Parse(args);
// Make sure we have either --file or --dir
if (string.IsNullOrEmpty(mtgJsonDirectory) && string.IsNullOrEmpty(mtgJsonFilename))
{
throw new Exception("You must either use --file or --dir.");
}
if (!string.IsNullOrEmpty(mtgJsonDirectory))
{
importByFile = false;
}
if (isMtgJson && importByFile)
{
inputName = mtgJsonFilename;
}
else if (isMtgJson && !importByFile)
{
inputName = mtgJsonDirectory;
if (!Directory.Exists(inputName))
{
throw new DirectoryNotFoundException(inputName);
}
}
else
{
throw new Exception("Please provide either --mtgdbinfo or --mtgjson arguments.");
}
mDataReader = new MtgJsonReader(
TinyIoCContainer.Current.Resolve <IMtgDataMapper <MtgJsonCard, MtgJsonSet> >("MtgJson"),
mLoggingService);
mDataReader.SkipTokens = skipTokens;
// Setup worker
mUpdaterBackgroundWorker = new BackgroundWorker();
mUpdaterBackgroundWorker.WorkerReportsProgress = true;
mUpdaterBackgroundWorker.WorkerSupportsCancellation = true;
mUpdaterBackgroundWorker.DoWork += new DoWorkEventHandler(bw_UpdaterDoWork);
mUpdaterBackgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_Completed);
mUpdaterBackgroundWorker.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
Console.WriteLine("Running worker thread...");
mUpdaterBackgroundWorker.RunWorkerAsync(new WorkArgs {
ImportByFile = importByFile, InputName = inputName
});
}
catch (Exception er)
{
string msg = string.Format("Error: {0}", er.Message);
mLoggingService.Fatal(er, msg);
Console.WriteLine(msg);
}
while (mUpdaterBackgroundWorker.IsBusy)
{
Thread.Sleep(100);
}
}
public async Task <HttpResponseMessage> ReservationVideo(int videoId)
{
if (!User.Identity.IsAuthenticated)
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "还未授权"));
}
var openId = User.Identity.Name;
try
{
var video = _videoServices.GetById(videoId);
if (video == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "不存在此视频！"));
}
var vm = new Reservation
{
VideoId = videoId,
OpenId = openId.ToString(),
CreatedDate = DateTime.Now
};
var message = new SingleSendMessagesVM {
ToUser = openId.ToString(), MsgType = "text", Text = new Message {
Content = $"你已成功预约了直播：【{video.Title}】"
}
};
var returnMsg = "预约成功";
var res = _reservationServices.GetById(vm.VideoId, vm.OpenId);
if (res != null)
{
_reservationServices.Delete(res);
message.Text = new Message {
Content = $"你已成功取消了直播：【{video.Title}】的预约"
};
returnMsg = "已取消预约";
}
else
{
_reservationServices.Create(vm);
}
var json = JsonConvert.SerializeObject(message, Newtonsoft.Json.Formatting.Indented,
new JsonSerializerSettings {
ContractResolver = new LowercaseContractResolver()
});
HttpContent content = new StringContent(json);
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
string accesstoken;
if (_cacheServices.IsSet("access_token"))
{
accesstoken = (string)_cacheServices.Get("access_token");
}
else
{
var atvm = await WeChatHepler.GetAccessTokenAsync(SettingsManager.WeiXin.AppId, SettingsManager.WeiXin.AppSecret);
accesstoken = atvm.access_token;
_cacheServices.Set("access_token", accesstoken, 120);
}
var result = await WeChatHepler.SingleSendMessagesAsync(accesstoken, content);
_logger.Info($"单发结果[errcode:{result.ErrCode},errmsg:{result.ErrMsg}]；消息主体：{json}");
return(Request.CreateResponse(HttpStatusCode.OK, returnMsg));
}
catch (Exception ex)
{
_logger.Fatal(ex);
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message, ex));
}
}
public void Fatal(object message)
{
_log.Fatal(message);
}
