public static LookupModel Lookup(
LoggerModel model,
IReadOnlyDictionary <HttpStatusCode, Func <bool> > statusCodeHandlers = null,
Action <Exception> exceptionHandler = null)
{
return(Post <LookupModel>("lookup", model, statusCodeHandlers, exceptionHandler));
}
public async Task <ApiResponse> Handle(GetAllUserNotificationsQuery request, CancellationToken cancellationToken)
{
ApiResponse response = new ApiResponse();
try
{
var lst = await _dbContext.LoggerDetails.Where(x => x.CreatedById == request.UserId).ToListAsync();
List <LoggerModel> loggerList = new List <LoggerModel>();
foreach (var item in lst)
{
LoggerModel obj = new LoggerModel();
obj.userId = item.CreatedById;
obj.createdDate = DateTime.Now;
obj.notificationId = item.NotificationId;
obj.loggerDetailsId = item.LoggerDetailsId;
obj.isRead = item.IsRead;
obj.userName = item.UserName;
obj.loggedDetail = item.LoggedDetail;
loggerList.Add(obj);
}
response.data.LoggerDetailsModelList = loggerList.OrderByDescending(x => x.createdDate).ToList();
response.StatusCode = StaticResource.successStatusCode;
response.Message = StaticResource.SuccessText;
}
catch (Exception ex)
{
response.StatusCode = StaticResource.failStatusCode;
response.Message = ex.Message;
}
return(response);
}
/// <summary>
/// Ignores a friend request between the specified
/// id (the source) and the logged in user (the destination)
/// </summary>
/// <param name="id">The id of the source of the friend request</param>
/// <returns>True if successful, false otherwise</returns>
public Boolean IgnoreFriendRequest(int id)
{
// Find the pending request
friend_pending pending = (from f in _dbContext.friend_pending
where f.source_id == id && f.destination_id == WebSecurity.CurrentUserId
select f).FirstOrDefault();
if (pending == null)
{
return(false);
}
// Ignore pending request
pending.ignored = true;
LoggerModel logFriendRequest = new LoggerModel()
{
Action = Logger.PlayerFriendLogType.IgnoreRequest.ToString(),
UserID = WebSecurity.CurrentUserId,
IPAddress = HttpContext.Current.Request.UserHostAddress,
TimeStamp = DateTime.Now,
ID1 = id,
IDType1 = Logger.LogIDType.User.ToString()
};
Logger.LogSingleEntry(logFriendRequest, _dbContext);
_dbContext.SaveChanges();
return(true);
}
public async Task <IHttpActionResult> PutLoggerModel(long id, LoggerModel loggerModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != loggerModel.Id)
{
return(BadRequest());
}
db.Entry(loggerModel).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LoggerModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
private static async Task InternalServerError(HttpContext context,
Exception exception,
string data,
string contentType = "text/plain")
{
await Task.Run(() =>
{
var request = context.Request;
var encodedPathAndQuery = request.GetEncodedPathAndQuery();
var logModel = new LoggerModel()
{
RequestHost = request.Host.Host,
RequestProtocol = request.Protocol,
RequestMethod = request.Method,
RequestPath = request.Path,
RequestPathAndQuery = encodedPathAndQuery,
RequestHeaders = request.Headers.ToDictionary(x => x.Key, x => (object)x.Value.ToString()),
RequestBody = string.Empty,
Exception = exception,
Data = data
};
Logger.HandleLogging(logModel).Error(LogTemplates.Error);
});
context.Response.Clear();
context.Response.ContentType = contentType;
context.Response.Headers.Add("Access-Control-Allow-Origin", "*");
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
await context.Response.WriteAsync(exception.Message, Encoding.UTF8);
}
/// <summary>
/// Logs a message through LoggerModule
/// </summary>
/// <param name="version">Version of the logger</param>
/// <param name="method">Logger method to call</param>
/// <param name="logger">Log data</param>
/// <param name="api_url">LoggerModule url</param>
/// <returns>Log id</returns>
public async Task <string> Log(string version, string method, LoggerModel logger, string api_url)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(api_url + "/");
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var callUrl = version + "/" + method;
if (logger != null)
{
//var json = JsonConvert.SerializeObject(logger);
HttpResponseMessage response = await client.PutAsJsonAsync(callUrl, logger);
if (response.IsSuccessStatusCode)
{
var data = await response.Content.ReadAsAsync <object>();
return(data.ToString());
}
else
{
throw new HttpResponseException(response);
}
}
}
return(null);
}
private void TrySendToServer(List <MovementModel> gestureToSend)
{
Print($"Gesture capturing finished.{Environment.NewLine}Sending gesture to server.");
var model = new LoggerModel {
Movements = gestureToSend, Buttons = new List <ButtonModel>()
};
var response = LoggerServerAPI.Lookup(
model,
new Dictionary <HttpStatusCode, Func <bool> >
{
{
HttpStatusCode.OK,
() => true
},
{
HttpStatusCode.NotFound,
() =>
{
ShowMenu("User not found.", false);
return(false);
}
}
},
exception => Print(exception.Message, LogType.Error));
if (response == null)
{
return;
}
ShowMenu($"Welcome user with ID {response.UserId}.", true);
}
internal static ModelCreateResult TryCreate(XmlNode node, XmlNode log4NetNode, out ModelBase model)
{
model = null;
switch (node.Name)
{
case Log4NetXmlConstants.Root:
model = new RootLoggerModel(node, false, LoggerDescriptor.Root);
return(ModelCreateResult.Success);
case Log4NetXmlConstants.Logger:
model = new LoggerModel(node, false, LoggerDescriptor.Logger);
return(ModelCreateResult.Success);
case Log4NetXmlConstants.Appender:
if (AppenderModel.TryCreate(node, log4NetNode, out AppenderModel appenderModel))
{
model = appenderModel;
return(ModelCreateResult.Success);
}
return(ModelCreateResult.UnknownAppender);
case Log4NetXmlConstants.Renderer:
model = new RendererModel(node);
return(ModelCreateResult.Success);
case Log4NetXmlConstants.Param:
model = new ParamModel(node);
return(ModelCreateResult.Success);
default:
return(ModelCreateResult.UnknownElement);
}
}
public void Write(List <string> Messages, string Context = "Service")
{
foreach (var msg in Messages)
{
LoggerModel logger = MakeLogger(msg, Context);
_loggerRepository.SaveLog(logger);
}
}
public static LoggerModel getLoggerModel()
{
if (loggerModel == null)
{
loggerModel = new LoggerModel();
}
return(loggerModel);
}
public void SaveLog(LoggerModel log)
{
using (StreamWriter sw = File.AppendText(log.Path))
{
sw.WriteLine(log.Message);
sw.Flush();
}
}
public ActionResult DeleteConfirmed(int id)
{
LoggerModel loggermodel = db.Loggers.Find(id);
db.Loggers.Remove(loggermodel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(long id)
{
LoggerModel loggerModel = await db.LoggerModels.FindAsync(id);
db.LoggerModels.Remove(loggerModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="logger"></param>
/// <returns></returns>
private static async Task InsertLogger(LoggerModel logger)
{
using (var db = new BaseModel())
{
await db.Logger.AddAsync(logger);
db.SaveChanges();
}
}
public void ExpandScopedEvents(EventSourceModel eventSource, LoggerModel model)
{
var scopeEvents = model.Events.Where(e => e.ReturnType == "System.IDisposable");
var events = new List <EventModel>(model.Events);
foreach (var eventModel in scopeEvents)
{
var eventBaseName = eventModel.Name;
eventModel.Name = $"Start{eventBaseName}";
eventModel.OpCode = EventOpcode.Start;
var eventTask = eventSource.GetEventTask(eventBaseName);
if (eventTask == null)
{
eventTask = eventSource.AddEventTask(eventBaseName);
}
eventModel.Task = eventTask;
if (eventModel.ReturnType == "System.IDisposable")
{
eventModel.IsScopedOperation = true;
eventModel.OperationName = GetEventOperationName(eventModel);
}
var stopEvent = new EventModel()
{
Arguments = eventModel.Arguments.Select(a => (EventArgumentModel)a.Clone()).ToArray(),
Name = $"Stop{eventBaseName}",
OpCode = EventOpcode.Stop,
Task = eventTask,
IsScopedOperation = eventModel.IsScopedOperation,
OperationName = eventModel.OperationName,
Keywords = eventModel.Keywords,
HasComplexArguments = eventModel.HasComplexArguments,
CorrelatesTo = eventModel,
ImplicitArguments = eventModel.ImplicitArguments,
Level = eventModel.Level,
MessageFormatter = eventModel.MessageFormatter,
};
eventModel.CorrelatesTo = stopEvent;
var index = events.IndexOf(eventModel);
if (index == events.Count - 1)
{
events.Add(stopEvent);
}
else
{
events.Insert(events.IndexOf(eventModel) + 1, stopEvent);
}
}
model.Events = events.ToArray();
}
private void CompleteQuest(int questID, user userToCheck, int?achievementID, bool autoSave)
{
if (userToCheck.status != (int)JPPConstants.UserStatus.Active || !userToCheck.is_player)
{
return;
}
//Check if the quest exists and is active, and if an instance already exists
quest_template questTemplate = _dbContext.quest_template.Find(questID);
if (questTemplate.state == (int)JPPConstants.AchievementQuestStates.Retired || _dbContext.quest_instance.Any(qi => qi.quest_id == questTemplate.id && qi.user_id == userToCheck.id))
{
return;
}
quest_instance newInstance = new quest_instance()
{
quest_id = questID,
user_id = userToCheck.id,
completed_date = DateTime.Now,
comments_disabled = true
};
_dbContext.quest_instance.Add(newInstance);
_unitOfWork.SystemRepository.AddNotification(
userToCheck.id,
userToCheck.id,
"You completed the quest [" + questTemplate.title + "]",
questTemplate.icon,
new UrlHelper(HttpContext.Current.Request.RequestContext).Action(
"IndividualQuest",
"Quests",
new { id = questTemplate.id }
) + "#" + newInstance.id + "-1",
false);
LoggerModel logQuestUnlock = new LoggerModel()
{
Action = Logger.QuestInstanceLogType.QuestUnlocked.ToString(),
UserID = userToCheck.id,
IPAddress = HttpContext.Current.Request.UserHostAddress,
TimeStamp = DateTime.Now,
ID1 = questID,
IDType1 = Logger.LogIDType.QuestTemplate.ToString(),
ID2 = achievementID,
IDType2 = Logger.LogIDType.AchievementTemplate.ToString(),
Value1 = "ID2 represents the ID of the achievement that triggered the quest unlock"
};
Logger.LogSingleEntry(logQuestUnlock, _dbContext);
if (autoSave)
{
Save();
}
}
/// <summary>
/// Accepts a friend request between the specified
/// id (the source) and the logged in user (the destination)
/// </summary>
/// <param name="id">The id of the source of the friend request</param>
/// <returns>True if successful, false otherwise</returns>
public Boolean AcceptFriendRequest(int id)
{
// Ssame user?
if (id == WebSecurity.CurrentUserId)
{
return(false);
}
// Find the pending request
friend_pending pending = (from f in _dbContext.friend_pending
where f.source_id == id && f.destination_id == WebSecurity.CurrentUserId
select f).FirstOrDefault();
if (pending == null)
{
return(false);
}
// Remove pending, then add friendships in both directions
_dbContext.friend_pending.Remove(pending);
friend f1 = new friend()
{
source_id = id,
destination_id = WebSecurity.CurrentUserId,
request_date = pending.request_date,
friended_date = DateTime.Now
};
friend f2 = new friend()
{
source_id = WebSecurity.CurrentUserId,
destination_id = id,
request_date = pending.request_date,
friended_date = f1.friended_date
};
_dbContext.friend.Add(f1);
_dbContext.friend.Add(f2);
_unitOfWork.AchievementRepository.CheckFriendSystemAchievements(WebSecurity.CurrentUserId);
_unitOfWork.AchievementRepository.CheckFriendSystemAchievements(f1.source_id);
LoggerModel logFriendRequest = new LoggerModel()
{
Action = Logger.PlayerFriendLogType.AcceptRequest.ToString(),
UserID = WebSecurity.CurrentUserId,
IPAddress = HttpContext.Current.Request.UserHostAddress,
TimeStamp = DateTime.Now,
ID1 = id,
IDType1 = Logger.LogIDType.User.ToString()
};
Logger.LogSingleEntry(logFriendRequest, _dbContext);
_dbContext.SaveChanges();
return(true);
}
public ActionResult Edit([Bind(Include = "LogID,userNameLog,transactionLog,dateLog")] LoggerModel loggermodel)
{
if (ModelState.IsValid)
{
db.Entry(loggermodel).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(loggermodel));
}
public async Task <IHttpActionResult> GetLoggerModel(long id)
{
LoggerModel loggerModel = await db.LoggerModels.FindAsync(id);
if (loggerModel == null)
{
return(NotFound());
}
return(Ok(loggerModel));
}
public ActionResult Create([Bind(Include = "LogID,userNameLog,transactionLog,dateLog")] LoggerModel loggermodel)
{
if (ModelState.IsValid)
{
db.Loggers.Add(loggermodel);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(loggermodel));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,DateTime,Message,Code,Key,Value,Email")] LoggerModel loggerModel)
{
if (ModelState.IsValid)
{
db.Entry(loggerModel).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(loggerModel));
}
public LoggerViewModel()
{
m_Model = new LoggerModel();
m_ClearLogCmd = new RelayCommand(() => ClearLogOutput(), true);
// this is different than how we're doing binding on other view models.
// theoretically (not that the assembler is doing this now :)) the logger
// could be running in real time. Other view models create a whole new view
// model with a backing model once they're done doing what they need to,
// but here we can't or otherwise we don't get any realtime log values.
m_Model.PropertyChanged += OnLogTextChanged;
}
public async Task <ActionResult> Create([Bind(Include = "Id,DateTime,Message,Code,Key,Value,Email")] LoggerModel loggerModel)
{
if (ModelState.IsValid)
{
db.LoggerModels.Add(loggerModel);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(loggerModel));
}
public async Task <IHttpActionResult> PostLoggerModel(LoggerModel loggerModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.LoggerModels.Add(loggerModel);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = loggerModel.Id }, loggerModel));
}
public TRKFile(string filePath, TimeSpan utcOffset)
: base(filePath, utcOffset)
{
LogFileExtension = ".trk";
SignatureStatus = SignatureStatus.NotSigned;
//get logger info
LoggerModel = TrackLogLines.FirstOrDefault(l => l[0] == 'P');
if (!string.IsNullOrEmpty(LoggerModel))
{
LoggerModel = LoggerModel.Substring(2).Trim();
}
}
// GET: /Logger/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LoggerModel loggermodel = db.Loggers.Find(id);
if (loggermodel == null)
{
return(HttpNotFound());
}
return(RedirectToAction("ExportJSON", new { userName = loggermodel.userNameLog }));
}
// GET: /Logger/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LoggerModel loggermodel = db.Loggers.Find(id);
if (loggermodel == null)
{
return(HttpNotFound());
}
return(View(loggermodel));
}
// GET: LoggerModels/Delete/5
public async Task <ActionResult> Delete(long?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
LoggerModel loggerModel = await db.LoggerModels.FindAsync(id);
if (loggerModel == null)
{
return(HttpNotFound());
}
return(View(loggerModel));
}
public async Task <IHttpActionResult> DeleteLoggerModel(long id)
{
LoggerModel loggerModel = await db.LoggerModels.FindAsync(id);
if (loggerModel == null)
{
return(NotFound());
}
db.LoggerModels.Remove(loggerModel);
await db.SaveChangesAsync();
return(Ok(loggerModel));
}
public LoggerToolViewModel(AbstractWorkspace workspace)
{
_workspace = workspace;
Name = "Logger";
Title = "Logger";
ContentId = "Logger";
_model = new LoggerModel();
Model = _model;
IsVisible = false;
_view = new LoggerToolView();
_view.DataContext = _model;
View = _view;
VEFModule.EventAggregator.GetEvent <LogEvent>().Subscribe(AddLog);
}
