public virtual async Task <IActionResult> PostAsync(AccountTicket user, RQ request)
{
if (request == null)
{
return(new BadRequestResult());
}
if (!Validate(user, request))
{
return(new ConflictObjectResult(State));
}
try
{
var model = Parse(user, request);
if (!Validate(user, request, model))
{
return(new ConflictObjectResult(State));
}
await _repository.SaveAsync(user, model);
return(new OkObjectResult(Parse(model)));
}
catch
{
return(new ConflictObjectResult(State));
}
}
public static void RegisterTicket(AccountTicket ticket)
{
ticket.ExpireTime = Environment.TickCount;
lock (Tickets)
Tickets.Add(ticket.Ticket, ticket);
Logger.Debug("Registered new ticket for account @'" + ticket.Account.Username + "'@");
}
public static void DestroyTicket(AccountTicket ticket)
{
lock (Tickets)
{
if (Tickets.ContainsKey(ticket.Ticket))
{
Tickets.Remove(ticket.Ticket);
Logger.Debug("Destroyed ticket for account @'" + ticket.Account.Username + "'@");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="ticket"></param>
/// <param name="content"></param>
public static void NotifyChatMessage(AccountTicket ticket, string content)
{
var message = new ChatMessage()
{
PlayerId = ticket.Account.Id,
Pseudo = ticket.Account.Pseudo,
Power = ticket.Account.Power,
Content = content,
Time = DateTime.Now.ToString("HH:mm:ss")
};
lock (ChatMessages)
{
if (ChatMessages.Count >= CACHE_MESSAGE_COUNT)
ChatMessages.RemoveAt(0);
ChatMessages.Add(message);
}
ctx.Value.Clients.All.notifyChatMessage(message);
}
public virtual async Task <IActionResult> GetAsync(AccountTicket user, int id)
{
try
{
var item = await _repository.GetAsync(user, id);
if (item != null)
{
return(new OkObjectResult(Parse(item)));
}
else
{
return(new NotFoundResult());
}
}
catch
{
return(new ConflictObjectResult(State));
}
}
public virtual void Setup()
{
var options = new DbContextOptionsBuilder <InitialDatabase>()
.UseInMemoryDatabase(databaseName: "Initial_Api")
.Options;
DbContext = new InitialDatabase(options)
{
IsTest = true
};
DbContext.Seed();
AppSettings = AppSettings.Default;
AccountService = new AccountService(new AccountRepository(DbContext), AppSettings);
AccountService.IsValid(CryptoHelper.Guid("U$1"), out AccountTicket accountTicket);
AccountTicket = accountTicket;
}
/// <summary>
///
/// </summary>
/// <param name="ticket"></param>
/// <param name="content"></param>
public static void NotifyChatMessage(AccountTicket ticket, string content)
{
var message = new ChatMessage()
{
PlayerId = ticket.Account.Id,
Pseudo = ticket.Account.Pseudo,
Power = ticket.Account.Power,
Content = content,
Time = DateTime.Now.ToString("HH:mm:ss")
};
lock (ChatMessages)
{
if (ChatMessages.Count >= CACHE_MESSAGE_COUNT)
{
ChatMessages.RemoveAt(0);
}
ChatMessages.Add(message);
}
ctx.Value.Clients.All.notifyChatMessage(message);
}
/// <summary>
/// 填充用户登录信息
/// </summary>
/// <param name="model">登录模型</param>
/// <param name="info">登录用户信息</param>
/// <returns>true 成功 false 失败</returns>
public bool FillLoginInfo(UserLoginInfo info, LoginViewModel model = null)
{
try
{
//写入Session信息
Session[SessionManager.Instance.SessionKey] = info;
if (model != null)
{
//写入用户信息票据，有效期为浏览器进程
AccountTicket usertick = new AccountTicket();
usertick.Password = model.Password;
usertick.SessionId = Session.SessionID;
usertick.UserAccount = model.LoginName;
string strticket = usertick.UserAccount;
CookieHelp.SetCookie(SessionManager.Instance.UserInfoTicketKey, strticket, DateTime.Now.AddDays(1));
}
//if (model.IsAutoLogin)
//{
// //下次自动登录，写入自动登录票据
// QM_LoginTicket loginticket = new QM_LoginTicket();
// loginticket.CreateTime = DateTime.Now;
// loginticket.UserName = model.UserAccount;
// loginticket.UserPassword = model.UserPassword;
// string strlogin = SerializableHelp.SerializableAndEncrypt<QM_LoginTicket>(loginticket);
// CookieHelp.SetCookie(SessionManager.Instance.UserAutoLoginTicketKey, strlogin, DateTime.MaxValue);
//}
}
catch (Exception ex)
{
//LogHelper.WriteLog("登录信息填充失败", ex);
return(false);
}
return(true);
}
/// <summary>
/// Creates an account ticket.
/// Documentation https://developers.google.com/analytics/v3/reference/provisioning/createAccountTicket
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated analytics service.</param>
/// <param name="body">A valid analytics v3 body.</param>
/// <returns>AccountTicketResponse</returns>
public static AccountTicket CreateAccountTicket(analyticsService service, AccountTicket body)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
// Make the request.
return(service.Provisioning.CreateAccountTicket(body).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Provisioning.CreateAccountTicket failed.", ex);
}
}
public async Task Create(TicketViewModel model)
{
//Map view model to domain model and create ticket record
Ticket ticket = config.CreateMapper().Map <TicketViewModel, Ticket>(model);
context.Tickets.Add(ticket);
context.SaveChanges();
context.Tickets.Attach(ticket);
//if ticket is associated to detection, create detection ticket records for each associated detect
if (model.DetectionId != null)
{
CreateDetectionTickets(Convert.ToInt32(model.DetectionId), ticket.TicketId);
}
//Check if device already exists, if so get deviceId, if not create a new one and return that device Id
int deviceId = GetDeviceId(model.Asset);
//Create a device ticket record
DeviceTicket dt = new DeviceTicket();
dt.DeviceId = deviceId;
dt.TicketId = ticket.TicketId;
context.DeviceTickets.Add(dt);
//Check if account already exists and whether it has been modified, if modified update attributes if does not exists, create a new account
int accountId = GetAccountId(model.Asset);
AccountTicket at = new AccountTicket();
at.AccountId = accountId;
at.TicketId = ticket.TicketId;
context.AccountTickets.Add(at);
context.SaveChanges();
await TicketNotification(model, ticket);
}
public virtual async Task <IActionResult> DeleteAsync(AccountTicket user, int id)
{
try
{
var model = await _repository.GetAsync(user, id);
if (model != null)
{
AuditDelete(user, model);
await _repository.SaveAsync(user, model);
return(new OkObjectResult(Parse(model)));
}
else
{
return(new NotFoundResult());
}
}
catch
{
return(new ConflictObjectResult(State));
}
}
protected virtual void Merge(AccountTicket user, M model, RQ request)
{
throw new NotImplementedException();
}
protected virtual void AuditDelete(AccountTicket user, M model)
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="ticket"></param>
public static void NotifyPlayerDisconnected(string exceptConnectionId, AccountTicket ticket)
{
ctx.Value.Clients.AllExcept(exceptConnectionId).notifyPlayerDisconnected(ticket.Account.Id);
}
/// <summary>
///
/// </summary>
/// <param name="ticket"></param>
public static void NotifyPlayerConnected(string exceptConnectionId, AccountTicket ticket)
{
ctx.Value.Clients.AllExcept(exceptConnectionId).notifyPlayerConnected(new { Id = ticket.Account.Id, Power = ticket.Account.Power, Pseudo = ticket.Account.Pseudo });
}
protected virtual bool Validate(AccountTicket user, RQ request)
{
return(true);
}
public virtual Task SaveAsync(AccountTicket user, T model)
{
throw new NotImplementedException();
}
public virtual Task <T> DeleteAsync(AccountTicket user, int id)
{
throw new NotImplementedException();
}
protected virtual M Parse(AccountTicket user, RQ request)
{
throw new NotImplementedException();
}
/// <summary>
///
/// </summary>
/// <param name="ticket"></param>
public static void NotifyPlayerConnected(string exceptConnectionId, AccountTicket ticket)
{
ctx.Value.Clients.AllExcept(exceptConnectionId).notifyPlayerConnected(new { Id = ticket.Account.Id, Power = ticket.Account.Power, Pseudo = ticket.Account.Pseudo });
}
/// <summary>
///
/// </summary>
/// <param name="ticket"></param>
public static void NotifyPlayerDisconnected(string exceptConnectionId, AccountTicket ticket)
{
ctx.Value.Clients.AllExcept(exceptConnectionId).notifyPlayerDisconnected(ticket.Account.Id);
}
/// <summary>
///
/// </summary>
/// <param name="account"></param>
/// <param name="characterDAO"></param>
/// <param name="type"></param>
public CharacterEntity(AccountTicket account, CharacterDAO characterDAO, EntityTypeEnum type = EntityTypeEnum.TYPE_CHARACTER)
: base(type, characterDAO.Id)
{
m_lastRegenTime = -1;
m_lastEmoteId = -1;
Away = false;
DatabaseRecord = characterDAO;
Alignment = characterDAO.Alignment;
Account = account;
PartyId = -1;
PartyInvitedPlayerId = -1;
PartyInviterPlayerId = -1;
GuildInvitedPlayerId = -1;
GuildInviterPlayerId = -1;
NotifyOnFriendConnection = true;
Quests = new List<CharacterQuest>(characterDAO.Quests.Select(record => new CharacterQuest(this, record)));
CharacterJobs = new JobBook(this);
Statistics = new GenericStats(characterDAO);
SpellBook = SpellBookFactory.Instance.Create(this);
Waypoints = CharacterWaypointRepository.Instance.GetByCharacterId(Id);
FrameManager = new FrameManager<CharacterEntity, string>(this);
Inventory = new CharacterInventory(this);
Bank = BankManager.Instance.GetBankByAccountId(AccountId);
PersonalShop = new PersistentInventory((int)EntityTypeEnum.TYPE_MERCHANT, Id);
Relations = SocialRelationRepository.Instance.GetByAccountId(AccountId);
var guildMember = GuildManager.Instance.GetMember(characterDAO.Guild.GuildId, Id);
if (guildMember != null)
if (type == EntityTypeEnum.TYPE_CHARACTER)
guildMember.CharacterConnected(this);
else
SetCharacterGuild(guildMember); // Merchant
SetChatChannel(ChatChannelEnum.CHANNEL_GUILD, () => DispatchGuildMessage);
SetChatChannel(ChatChannelEnum.CHANNEL_GROUP, () => DispatchPartyMessage);
RefreshPersonalShopTaxe();
CheckRestrictions();
LoadEquippedMount();
}
public virtual Task <IEnumerable <T> > GetAllAsync(AccountTicket user)
{
throw new NotImplementedException();
}
