public new Sage.Common.Syndication.FeedEntry GetFeedEntry(string id)
{
PostalAddressFeedEntry result;
Account account = new Account();
Identity identity = new Identity(account.EntityName, id);
AccountDocument accountDocument = (AccountDocument)_entity.GetDocument(identity, _emptyToken, _context.Config);
if ((accountDocument.LogState == LogState.Deleted) ||
(accountDocument.addresses.documents.Count == 0))
{
PostalAddressFeedEntry deletedPayload = new PostalAddressFeedEntry();
deletedPayload.UUID = GetUuid(id);
deletedPayload.IsDeleted = true;
return(deletedPayload);
}
Document document = accountDocument.addresses.documents[0];
result = (PostalAddressFeedEntry)GetTransformedPayload(document);
string taUuid = GetTradingAccountUuid(accountDocument.Id);
#warning no reference for trading accounts exists in the contract
return(result);
}
private async void UnlockAccountMessageReceived(UnlockAccountMessage message)
{
if (this.m_connection.State == ClientConnectionState.LOGIN_FAILED)
{
if (ServerStatus.Status == ServerStatusType.SHUTDOWN_STARTED || ServerStatus.Status == ServerStatusType.MAINTENANCE)
{
UnlockAccountFailedMessage unlockAccountFailedMessage = new UnlockAccountFailedMessage();
unlockAccountFailedMessage.SetErrorCode(UnlockAccountFailedMessage.ErrorCode.SERVER_MAINTENANCE);
this.SendMessage(unlockAccountFailedMessage);
return;
}
IOperationResult <string> getResult = await ServerProxy.AccountDatabase.Get(message.GetAccountId());
if (!getResult.Success)
{
UnlockAccountFailedMessage unlockAccountFailedMessage = new UnlockAccountFailedMessage();
unlockAccountFailedMessage.SetErrorCode(UnlockAccountFailedMessage.ErrorCode.UNLOCK_UNAVAILABLE);
this.SendMessage(unlockAccountFailedMessage);
return;
}
AccountDocument accountDocument = CouchbaseDocument.Load <AccountDocument>(getResult.Value);
if (accountDocument.PassToken != message.GetPassToken() || accountDocument.State != AccountState.LOCKED)
{
UnlockAccountFailedMessage unlockAccountFailedMessage = new UnlockAccountFailedMessage();
unlockAccountFailedMessage.SetErrorCode(UnlockAccountFailedMessage.ErrorCode.UNLOCK_UNAVAILABLE);
this.SendMessage(unlockAccountFailedMessage);
return;
}
if (accountDocument.StateArg != null && !accountDocument.StateArg.Equals(message.GetUnlockCode(), StringComparison.InvariantCultureIgnoreCase))
{
UnlockAccountFailedMessage unlockAccountFailedMessage = new UnlockAccountFailedMessage();
unlockAccountFailedMessage.SetErrorCode(UnlockAccountFailedMessage.ErrorCode.UNLOCK_FAILED);
this.SendMessage(unlockAccountFailedMessage);
return;
}
accountDocument.State = AccountState.NORMAL;
accountDocument.StateArg = null;
IOperationResult <string> updateResult = await ServerProxy.AccountDatabase.Update(accountDocument.Id, CouchbaseDocument.Save(accountDocument));
if (!updateResult.Success)
{
UnlockAccountFailedMessage unlockAccountFailedMessage = new UnlockAccountFailedMessage();
unlockAccountFailedMessage.SetErrorCode(UnlockAccountFailedMessage.ErrorCode.UNLOCK_UNAVAILABLE);
this.SendMessage(unlockAccountFailedMessage);
return;
}
UnlockAccountOkMessage unlockAccountOkMessage = new UnlockAccountOkMessage();
unlockAccountOkMessage.SetAccountId(message.GetAccountId());
unlockAccountOkMessage.SetPassToken(message.GetPassToken());
this.SendMessage(unlockAccountOkMessage);
}
}
public static ProxySession Create(ClientConnection clientConnection, AccountDocument accountDocument)
{
long id = ProxySessionManager.GetScrambledId();
ProxySession proxySession = new ProxySession(id, clientConnection, accountDocument);
Logging.Assert(ProxySessionManager.m_sessions.TryAdd(id, proxySession), "ProxySessionManager.m_sessions.TryAdd(id, proxySession) return false");
return(proxySession);
}
public override FeedEntry GetFeedEntry(string resource)
{
Identity id = new Identity(_entity.EntityName, resource);
AccountDocument accountDocument = (AccountDocument)_entity.GetDocument(id, _emptyToken, _context.Config);
if (accountDocument.LogState == LogState.Deleted)
{
FeedEntry e = new FeedEntry();
e.IsDeleted = true;
return(e);
}
return(GetTransformedPayload(accountDocument));
}
private async void UpdatePlayTimeSeconds()
{
IOperationResult <string> getResult = await ServerProxy.AccountDatabase.Get(this.AccountId);
if (getResult.Success)
{
AccountDocument accountDocument = CouchbaseDocument.Load <AccountDocument>(getResult.Value);
accountDocument.SessionCount += 1;
accountDocument.PlayTimeSeconds += (int)DateTime.UtcNow.Subtract(this.m_startSessionTime).TotalSeconds;
IOperationResult <string> updateResult = await ServerProxy.AccountDatabase.Update(this.AccountId, CouchbaseDocument.Save(accountDocument), getResult.Cas);
if (!updateResult.Success)
{
this.UpdatePlayTimeSeconds();
}
}
}
public override SdataTransactionResult Add(PayloadBase payload, List <SyncFeedEntryLink> links)
{
string accountUuid = "";
SdataTransactionResult sdTrResult;
PhoneNumberPayload phoneNumberPayload = payload as PhoneNumberPayload;
bool isFax = false;;
bool isPhone = false;
if (phoneNumberPayload.PhoneNumbertype.type.Equals("general", StringComparison.InvariantCultureIgnoreCase))
{
isPhone = true;
}
else if (phoneNumberPayload.PhoneNumbertype.type.Equals("fax", StringComparison.InvariantCultureIgnoreCase))
{
isFax = true;
}
else
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = "Only primary phonenumbers with type general and fax where accepted";
sdTrResult.HttpMethod = "POST";
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = phoneNumberPayload.SyncUuid;
return(sdTrResult);
}
foreach (SyncFeedEntryLink link in links)
{
if ((!String.IsNullOrEmpty(link.PayloadPath)) &&
link.PayloadPath.Equals(_tradingAccountUuidPayloadPath,
StringComparison.InvariantCultureIgnoreCase))
{
accountUuid = link.Uuid;
break;
}
}
if (String.IsNullOrEmpty(accountUuid))
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = "Trading Account UUID was missing";
sdTrResult.HttpMethod = "POST";
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = phoneNumberPayload.SyncUuid;
return(sdTrResult);
}
string accountId = GetTradingAccountLocalId(accountUuid);
if (String.IsNullOrEmpty(accountId))
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = String.Format("Trading Account UUID {0} was not linked", accountUuid);
sdTrResult.HttpMethod = "POST";
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = phoneNumberPayload.SyncUuid;
return(sdTrResult);
}
Account account = new Account();
Identity accIdentity = new Identity(account.EntityName, accountId);
AccountDocument accountDocument = account.GetDocument(
accIdentity, _emptyToken, _context.Config) as AccountDocument;
Document document = null;
bool doAdd = false;
document = GetTransformedDocument(payload, links);
if (isPhone)
{
document.Id = accountId + Sage.Integration.Northwind.Application.API.Constants.PhoneIdPostfix;
}
if (isFax)
{
document.Id = accountId + Sage.Integration.Northwind.Application.API.Constants.FaxIdPostfix;
}
if (accountDocument.addresses.documents.Count == 0)
{
accountDocument.CrmId = GetTradingAccountUuid(document.Id);
accountDocument.phones.documents.Add(document);
doAdd = true;
}
else
{
for (int index = 0; index < accountDocument.phones.documents.Count; index++)
{
if (accountDocument.phones.documents[index].Id.Equals(document.Id, StringComparison.InvariantCultureIgnoreCase))
{
if (((PhoneDocument)accountDocument.phones.documents[index]).number.IsNull)
{
doAdd = true;
accountDocument.phones.documents[index] = document;
}
break;
}
}
}
if (!doAdd)
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = "Trading Account has already this primary phone type";
sdTrResult.HttpMethod = "POST";
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = phoneNumberPayload.SyncUuid;
return(sdTrResult);
}
List <TransactionResult> transactionResults = new List <TransactionResult>();
account.Update(accountDocument, _context.Config, ref transactionResults);
sdTrResult = Helper.GetSdataTransactionResult(transactionResults,
_context.OriginEndPoint, SupportedResourceKinds.tradingAccounts);
if (sdTrResult != null)
{
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.HttpMessage = "POST";
}
return(sdTrResult);
}
public ProxySession(long sessionId, ClientConnection clientConnection, AccountDocument account) : base(sessionId, account.Id, clientConnection.Location)
{
this.ClientConnection = clientConnection;
this.m_chatUnbanTime = -1; // TODO: Implement this.
this.m_startSessionTime = DateTime.UtcNow;
}
private async void LoginMessageReceived(LoginMessage message)
{
if (this.m_connection.State == ClientConnectionState.DEFAULT &&
this.CheckClientVersion(message.GetClientMajorVersion(), message.GetClientBuildVersion(), message.GetAppVersion(), message.GetResourceSha(), message.IsAndroidClient()) &&
this.CheckServerCapabilities())
{
this.m_connection.Messaging.SetScramblerSeed(message.GetScramblerSeed());
this.m_connection.SetState(ClientConnectionState.LOGIN);
AccountDocument accountDocument;
if (message.GetAccountId().IsZero() && message.GetPassToken() == null)
{
IOperationResult <ulong> incrementSeedResult = await ServerProxy.AccountDatabase.IncrementSeed();
if (!incrementSeedResult.Success)
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.SERVER_MAINTENANCE);
loginFailedMessage.SetReason("Internal server error");
this.SendMessage(loginFailedMessage);
return;
}
accountDocument = new AccountDocument((long)incrementSeedResult.Value);
accountDocument.Init();
accountDocument.Country = this.m_connection.Location;
IOperationResult <string> createAccountResult = await ServerProxy.AccountDatabase.Insert((long)incrementSeedResult.Value, CouchbaseDocument.Save(accountDocument));
if (!createAccountResult.Success)
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.SERVER_MAINTENANCE);
loginFailedMessage.SetReason("Internal server error");
this.SendMessage(loginFailedMessage);
return;
}
}
else
{
IOperationResult <string> getResult = await ServerProxy.AccountDatabase.Get(message.GetAccountId());
if (!getResult.Success)
{
if (getResult.Status == ResponseStatus.KeyNotFound)
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.ACCOUNT_NOT_EXISTS);
this.SendMessage(loginFailedMessage);
}
else
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.SERVER_MAINTENANCE);
loginFailedMessage.SetReason("Internal server error");
this.SendMessage(loginFailedMessage);
}
return;
}
accountDocument = CouchbaseDocument.Load <AccountDocument>(getResult.Value);
if (accountDocument.PassToken != message.GetPassToken())
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.ACCOUNT_NOT_EXISTS);
this.SendMessage(loginFailedMessage);
return;
}
}
if (accountDocument.State != AccountState.NORMAL)
{
switch (accountDocument.State)
{
case AccountState.BANNED:
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.BANNED);
loginFailedMessage.SetReason(accountDocument.StateArg);
this.SendMessage(loginFailedMessage);
return;
}
case AccountState.LOCKED:
{
LoginFailedMessage loginFailedMessage = new LoginFailedMessage();
loginFailedMessage.SetErrorCode(LoginFailedMessage.ErrorCode.ACCOUNT_LOCKED);
this.SendMessage(loginFailedMessage);
return;
}
}
}
ProxySession session = ProxySessionManager.Create(this.m_connection, accountDocument);
RedisValue prevSession = await ServerProxy.SessionDatabase.GetSet(accountDocument.Id, session.Id.ToString());
if (!prevSession.IsNull)
{
long prevSessionId = long.Parse(prevSession);
ServerMessageManager.SendMessage(new StopSessionMessage
{
Reason = 1,
SessionId = prevSessionId
}, ServerManager.GetProxySocket(prevSessionId));
}
session.SetSocket(ServerCore.Socket); // Proxy
LoginOkMessage loginOkMessage = new LoginOkMessage();
loginOkMessage.SetAccountId(accountDocument.Id);
loginOkMessage.SetHomeId(accountDocument.Id);
loginOkMessage.SetPassToken(accountDocument.PassToken);
loginOkMessage.SetFacebookId(accountDocument.FacebookId);
loginOkMessage.SetGamecenterId(accountDocument.GamecenterId);
loginOkMessage.SetServerMajorVersion(LogicVersion.MAJOR_VERSION);
loginOkMessage.SetServerBuildVersion(LogicVersion.BUILD_VERSION);
loginOkMessage.SetContentVersion(ResourceManager.GetContentVersion());
loginOkMessage.SetServerEnvironment(EnvironmentSettings.Environment);
loginOkMessage.SetSessionCount(accountDocument.SessionCount);
loginOkMessage.SetPlayTimeSeconds(accountDocument.PlayTimeSeconds);
loginOkMessage.SetAccountCreatedDate(accountDocument.CreateTime.ToString());
loginOkMessage.SetStartupCooldownSeconds(ServerProxy.GetStartupCooldownSeconds());
loginOkMessage.SetRegion(this.m_connection.Location);
loginOkMessage.SetFacebookAppId(ResourceSettings.FacebookAppId);
loginOkMessage.SetGoogleServiceId(ResourceSettings.GoogleServiceId);
loginOkMessage.SetContentUrlList(ResourceSettings.ContentUrlList);
loginOkMessage.SetChronosContentUrlList(ResourceSettings.ChronosContentUrlList);
this.SendMessage(loginOkMessage);
this.m_connection.SetSession(session);
this.m_connection.SetState(ClientConnectionState.LOGGED);
if (this.m_connection.State == ClientConnectionState.LOGGED)
{
accountDocument.SessionCount += 1;
accountDocument.LastSessionTime = TimeUtil.GetTimestamp();
ServerRequestManager.Create(new BindServerSocketRequestMessage
{
ServerType = 9,
ServerId = ServerManager.GetDocumentSocket(9, accountDocument.Id).ServerId,
SessionId = session.Id
}, ServerCore.Socket, 5).OnComplete = this.OnGameServerBound;
await ServerProxy.AccountDatabase.Update(accountDocument.Id, CouchbaseDocument.Save(accountDocument));
}
else
{
this.m_connection.DestructSession();
}
}
}
public static async void SaveAccount(AccountDocument document)
{
await ServerAdmin.AccountDatabase.Update(document.Id, CouchbaseDocument.Save(document));
}
public override SdataTransactionResult Add(FeedEntry entry)
{
string accountUuid = string.Empty;
SdataTransactionResult sdTrResult;
ContactFeedEntry contactEntry = entry as ContactFeedEntry;
if (contactEntry.primacyIndicator)
{
// is primary
}
else
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = "Only primary contacts supported";
sdTrResult.HttpMethod = HttpMethod.POST;
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = SupportedResourceKinds.contacts;
sdTrResult.Uuid = contactEntry.UUID.ToString();
AttachDiagnosis(sdTrResult);
return(sdTrResult);
}
if (contactEntry.tradingAccount != null)
{
accountUuid = contactEntry.tradingAccount.UUID.ToString();
}
if (String.IsNullOrEmpty(accountUuid) || Guid.Empty.ToString() == accountUuid)
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = "Trading Account UUID was missing";
sdTrResult.HttpMethod = HttpMethod.POST;
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = contactEntry.UUID.ToString();
AttachDiagnosis(sdTrResult);
return(sdTrResult);
}
string accountId = GetTradingAccountLocalId(accountUuid);
if (String.IsNullOrEmpty(accountId))
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = String.Format("Trading Account UUID {0} was not linked", accountUuid);
sdTrResult.HttpMethod = HttpMethod.POST;
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = contactEntry.UUID.ToString();
AttachDiagnosis(sdTrResult);
return(sdTrResult);
}
Account account = new Account();
Identity accIdentity = new Identity(account.EntityName, accountId);
AccountDocument accountDocument = account.GetDocument(
accIdentity, _emptyToken, _context.Config) as AccountDocument;
accountDocument.CrmId = accountUuid;
Document document = null;
bool doAdd = false;
document = GetTransformedDocument(entry);
if (accountDocument.people.documents.Count == 0)
{
accountDocument.people.documents.Add(document);
doAdd = true;
}
else
{
PersonDocument personDocument = accountDocument.people.documents[0] as PersonDocument;
if (personDocument.firstname.IsNull &&
personDocument.lastname.IsNull)
{
accountDocument.people.documents[0] = document;
doAdd = true;
}
}
if (!doAdd)
{
sdTrResult = new SdataTransactionResult();
sdTrResult.HttpMessage = "Trading Account has already a primary contact";
sdTrResult.HttpMethod = HttpMethod.POST;
sdTrResult.HttpStatus = System.Net.HttpStatusCode.Forbidden;
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.Uuid = contactEntry.UUID.ToString();
AttachDiagnosis(sdTrResult);
return(sdTrResult);
}
List <TransactionResult> transactionResults = new List <TransactionResult>();
account.Update(accountDocument, _context.Config, ref transactionResults);
sdTrResult = GetSdataTransactionResult(transactionResults,
_context.OriginEndPoint, SupportedResourceKinds.tradingAccounts);
if (sdTrResult != null)
{
sdTrResult.ResourceKind = _resourceKind;
sdTrResult.HttpMessage = "POST";
}
return(sdTrResult);
}
