private void ValidateAndInitializeSessionIds()
{
if (Destination == Source)
{
throw new InvalidOperationException("Client cannot invite himself to the session");
}
if (SessionsRepository.IsSessionFull(_sourceSessionId))
{
throw new InvalidOperationException("Session is full");
}
if (SessionsRepository.IsSessionFull(DestinationSessionId))
{
throw new InvalidOperationException($"Client's {Destination.Id} session is full");
}
if (Destination.GotInviteFrom(Source.Id))
{
throw new InvalidOperationException(
$"Already invited client with ID: {Destination.Id}");
}
DestinationSessionId = SessionsRepository.GetSessionId(Destination);
if (DestinationSessionId == _sourceSessionId)
{
throw new InvalidOperationException("Invited client is already in this session");
}
}
protected override void ConfigureApplicationContainer(TinyIoCContainer container)
{
base.ConfigureApplicationContainer(container);
var eventsStore = new EventsStore();
var sessionsRepository = new SessionsRepository(eventsStore);
var timelineMessageRepository = new TimelineMessageRepository();
var followersRepository = new FollowersRepository();
var subscriptionsRepository = new SubscriptionsRepository(eventsStore, followersRepository);
var eventPublisher = new EventPublisher();
var eventPublisherWithStorage = new EventPublisherWithStorage(eventsStore, eventPublisher);
eventPublisher.Subscribe(new SessionHandler(sessionsRepository));
eventPublisher.Subscribe(new UpdateTimeline(timelineMessageRepository));
eventPublisher.Subscribe(new NotifyFollowerOfFolloweeMessage(followersRepository, subscriptionsRepository, eventPublisherWithStorage));
eventPublisher.Subscribe(new UpdateFollowers(followersRepository));
container.Register <IEventPublisher>(eventPublisherWithStorage);
container.Register <IUserIdentitiesRepository>(new UserIdentitiesRepository(eventsStore));
container.Register <ISessionsRepository>(sessionsRepository);
container.Register <ITimelineMessageRepository>(timelineMessageRepository);
container.Register <IMessagesRepository>(new MessagesRepository(eventsStore));
}
// Business Logic pass through code to Select All Sessions
public List <SessionsEntity> SelectAllSessions()
{
var returnedEntities = new List <SessionsEntity>();
try
{
using (var repository = new SessionsRepository())
{
foreach (var entity in repository.SelectAll())
{
entity.FeeCap = GetFeeCap(entity.Fee);
returnedEntities.Add(entity);
}
}
return(returnedEntities);
}
catch (Exception ex)
{
//Log exception error
_loggingHandler.LogEntry(ExceptionHandler.GetExceptionMessageFormatted(ex), true);
throw new Exception("BusinessLogic:SessionsBusiness::SelectAllSessions::Error occured.", ex);
}
}
public ServerSendMessage(ClientData source, ISessionsRepository sessionsRepository,
IPacketFormatter packetFormatter, string messageToSend)
: base(source, sessionsRepository, packetFormatter, Operation.Message, Status.Ok)
{
_messageToSend = messageToSend;
_sourceSessionId = SessionsRepository.GetSessionId(Source);
}
private void ValidateAndInitializeSessionIds()
{
if (Destination == Source)
{
throw new InvalidOperationException("Client cannot accept invitation (or invite) himself");
}
if (!Source.GotInviteFrom(Destination.Id))
{
throw new InvalidOperationException(
$"Client have not received an invitation from a client with ID {Destination.Id}");
}
DestinationSessionId = SessionsRepository.GetSessionId(Destination);
var sourceSessionId = SessionsRepository.GetSessionId(Source);
if (DestinationSessionId == sourceSessionId)
{
throw new InvalidOperationException($"Client {Destination.Id} is already in your session");
}
if (SessionsRepository.IsSessionFull(sourceSessionId))
{
throw new InvalidOperationException("Client's session is full");
}
if (SessionsRepository.IsSessionFull(DestinationSessionId))
{
throw new InvalidOperationException("Inviter session is full");
}
SessionsRepository.UpdateClientSessionId(Source, DestinationSessionId);
}
public YelpController(YelpRepository repository, AcceptableRestaurantsRepository acceptableRestaurantsRepository, SessionsRepository sessionsRepository, UserSessionsRepository userSessionsRepository)
{
_repository = repository;
_acceptableRestaurantsRepository = acceptableRestaurantsRepository;
_sessionsRepository = sessionsRepository;
_userSessionsRepository = userSessionsRepository;
}
public ServerInvite(ClientData source, int destinationId, ISessionsRepository sessionsRepository,
IPacketFormatter packetFormatter)
: base(source, sessionsRepository, packetFormatter, Operation.Invite, Status.Ok)
{
_destinationId = destinationId;
_sourceSessionId = SessionsRepository.GetSessionId(Source);
}
public CodeCamperUnitOfWork(string nameOrConnectionString = "CodeCamper")
: base(new CodeCamperDbContext(nameOrConnectionString))
{
RoomsRepository = new EntityFrameworkReadRepository<Room>(DbContext);
TimeSlotsRepository = new EntityFrameworkReadRepository<TimeSlot>(DbContext);
TracksRepository = new EntityFrameworkReadRepository<Track>(DbContext);
PersonsRepository = new PersonsRepository(DbContext);
SessionsRepository = new SessionsRepository(DbContext);
AttendanceRepository = new AttendanceRepository(DbContext);
}
public void DeleteSession(AxolotlAddress address)
{
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(address.GetName(), address.GetDeviceId());
if (sessions != null && sessions.Count > 0)
{
Sessions session = sessions.First();
sessionsRepository.Delete(session);
}
}
public override void Execute()
{
base.Execute();
Source.RemoveAllPendingInvites();
Destination.RemoveAllPendingInvites();
var sourceNewSessionId = SessionsRepository.GetSessionId(Source);
var initialPacket = new Packet(Operation.GetId, Status.Initial, sourceNewSessionId, Source.Id);
Source.SendTo(PacketFormatter.Serialize(initialPacket));
}
private void ValidateAndInitializeDestinationId()
{
try
{
Destination = SessionsRepository.GetClientById(_destinationId);
}
catch (InvalidOperationException)
{
throw new InvalidOperationException($"There is no user with ID: {_destinationId}");
}
}
public void DeleteAllSessions(string name)
{
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(name);
if (sessions != null && sessions.Count > 0)
{
foreach (Sessions session in sessions)
{
sessionsRepository.Delete(session);
}
}
}
public async Task <bool> Get(string guid)
{
var userRepository = new SessionsRepository();
try
{
return(await userRepository.SessionIsAuthorized(Guid.Parse(guid)));
}
catch (Exception ex)
{
return(false);
}
}
public SessionRecord LoadSession(AxolotlAddress address)
{
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(address.GetName(), address.GetDeviceId());
if (sessions != null && sessions.Count > 0)
{
Sessions session = sessions.First();
SessionRecord sessionRecord = new SessionRecord(session.Record);
return(sessionRecord);
}
return(new SessionRecord());
}
public void StoreSession(AxolotlAddress address, SessionRecord record)
{
DeleteSession(address);
SessionsRepository sessionsRepository = new SessionsRepository();
Sessions session = new Sessions()
{
RecipientId = address.GetName(),
DeviceId = address.GetDeviceId(),
Record = record.Serialize()
};
sessionsRepository.Save(session);
}
protected override void ValidateAndInitializeCommandArguments()
{
Destination = Source;
DestinationSessionId = SessionsRepository.GetSessionId(Destination);
// source is only client in session
if (!SessionsRepository.IsSessionFull(DestinationSessionId))
{
throw new InvalidOperationException(
"Closing communication session and moving to new one is possible only if other client is in your session");
}
SessionsRepository.UpdateClientSessionId(Destination, Guid.NewGuid());
DestinationSessionId = SessionsRepository.GetSessionId(Destination);
}
public async Task RemoveUserAsync(UserInfo userInfo)
{
var authorizedUsersRepository = new SessionsRepository();
var email = userInfo.Email;
await authorizedUsersRepository.RemoveSessionAsync(email);
databaseConnection.GetNewConnection();
await using (databaseConnection.DbConnection)
{
var sql = $"DELETE FROM Users WHERE email = @email;";
await databaseConnection.DbConnection.ExecuteAsync(sql, new { email });
}
}
public List <uint> GetSubDeviceSessions(string recipientId)
{
List <uint> retVal = new List <uint>();
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(recipientId);
if (sessions != null && sessions.Count > 0)
{
foreach (Sessions session in sessions)
{
retVal.Add(session.DeviceId);
}
}
return(retVal.Count > 0 ? retVal : null);
}
// Business Logic pass through code to Delete a Session by ID
public bool DeleteSessionById(int id)
{
try
{
using (var repository = new SessionsRepository())
{
return(repository.DeleteById(id));
}
}
catch (Exception ex)
{
//Log exception error
_loggingHandler.LogEntry(ExceptionHandler.GetExceptionMessageFormatted(ex), true);
throw new Exception("BusinessLogic:SessionsBusiness::DeleteSessionById::Error occured.", ex);
}
}
private void ValidateAndInitializeDestination()
{
if (!SessionsRepository.IsSessionFull(_sourceSessionId))
{
throw new InvalidOperationException("No other client in client's session");
}
try
{
Destination = SessionsRepository.GetSecondClientFromSession(_sourceSessionId, Source);
}
catch (InvalidOperationException)
{
throw new InvalidOperationException("Error, try again");
}
DestinationSessionId = _sourceSessionId;
}
public void ClearRecipient(string recipientId)
{
IdentityKeysRepository identityKeysRepository = new IdentityKeysRepository();
List <IdentityKeys> identityKeys = identityKeysRepository.GetIdentityKeys(recipientId);
if (identityKeys != null && identityKeys.Count > 0)
{
identityKeysRepository.Delete(identityKeys.First());
}
SessionsRepository sessionsRepository = new SessionsRepository();
List <Sessions> sessions = sessionsRepository.GetSessions(recipientId);
if (sessions != null && sessions.Count > 0)
{
sessionsRepository.Delete(sessions.First());
}
}
protected void btnLogin_onclick(object sender, EventArgs e)
{
RepoMapConnect RMCaccount = new RepoMapConnect(databaseTable.PrimaryAccount);
PrimaryAccountMap PAM = new PrimaryAccountMap();
PAM.username = txtUsername.Text;
RMCaccount.map = RMCaccount.repo.selectData(PAM);
if (RMCaccount.map.password == RMCaccount.func.hashedValue(txtPassword.Text + RMCaccount.map.salt))
{
SessionsMap map = new SessionsMap(RMCaccount.map.id);
SessionsRepository repo = new SessionsRepository();
repo.executeData(map, sqlStatementType.Insert);
HttpCookie cookie = RMCaccount.func.createcookie(map.sessionVal, "SessionCookie");
Response.Cookies.Add(cookie);
Response.Redirect("Account/view.aspx");
}
}
protected void btnLogin_onclick(object sender, EventArgs e)
{
RepoMapConnect RMCaccount = new RepoMapConnect(databaseTable.PrimaryAccount);
PrimaryAccountMap PAM = new PrimaryAccountMap();
PAM.username = txtUsername.Text;
RMCaccount.map = RMCaccount.repo.selectData(PAM);
if (RMCaccount.map.password == RMCaccount.func.hashedValue(txtPassword.Text + RMCaccount.map.salt))
{
SessionsMap map = new SessionsMap(RMCaccount.map.id);
SessionsRepository repo = new SessionsRepository();
repo.executeData(map, sqlStatementType.Insert);
HttpCookie cookie = RMCaccount.func.createcookie(map.sessionVal, "SessionCookie");
Response.Cookies.Add(cookie);
Response.Redirect("Account/view.aspx");
}
}
// Begin counting available requests.
internal async Task StartQuotaCount(SheetsService sheetsService, string sessionsSpreadsheetId, CancellationToken cancellationToken)
{
// Await limiter repository
await SessionRequestsLimiter._limiterSemaphore.WaitAsync();
try
{
// Throw if cancellation has been requested after semaphore has been released
cancellationToken.ThrowIfCancellationRequested();
// Engage initialization mode to await deadlock when obtaining initial available quota
this._initializationMode = true;
this._stopped = false;
await Task.Run(() => this.AvailableQuota = SessionsRepository.RetrieveInitialAvailableQuota(sheetsService, sessionsSpreadsheetId));
}
// Finally release limiter repository
finally
{
this._initializationMode = false;
SessionRequestsLimiter._limiterSemaphore.Release();
}
// Do not await
#pragma warning disable CS4014 // Do not await task to return on operational and still maintain data consistency.
Task.Run(async() =>
{
while (!this._stopped)
{
await Task.Delay(1000, cancellationToken);
if ((this.AvailableQuota + SessionRequestsLimiter.QuotaRequestsPerSec) > SessionRequestsLimiter.QuotaRequestsLimit)
{
this.AvailableQuota = SessionRequestsLimiter.QuotaRequestsLimit;
}
else
{
this.AvailableQuota += SessionRequestsLimiter.QuotaRequestsPerSec;
}
}
}, cancellationToken);
#pragma warning restore CS4014
}
// Business Logic pass through code to Update Session
public bool UpdateSession(SessionsEntity entity)
{
try
{
bool bOpDoneSuccessfully;
using (var repository = new SessionsRepository())
{
bOpDoneSuccessfully = repository.Update(entity);
}
return(bOpDoneSuccessfully);
}
catch (Exception ex)
{
//Log exception error
_loggingHandler.LogEntry(ExceptionHandler.GetExceptionMessageFormatted(ex), true);
throw new Exception("BusinessLogic:SessionsBusiness::UpdateSession::Error occured.", ex);
}
}
public void Clear()
{
IdentityKeysRepository identityKeysRepository = new IdentityKeysRepository();
identityKeysRepository.DeleteAll();
PreKeysRepository preKeysRepository = new PreKeysRepository();
preKeysRepository.DeleteAll();
SenderKeysRepository senderKeysRepository = new SenderKeysRepository();
senderKeysRepository.DeleteAll();
SessionsRepository sessionsRepository = new SessionsRepository();
sessionsRepository.DeleteAll();
SignedPreKeysRepository signedPreKeysRepository = new SignedPreKeysRepository();
signedPreKeysRepository.DeleteAll();
}
// Log out off the google apis
public async Task DisconnectAsync()
{
// Set connection state flag to null.
if (this.IsConnected != false)
{
this.IsConnected = null;
}
// Stop available quota execution.
SessionRequestsLimiter.Instance.StopQuotaCount();
// Await ending session
await this._sessionsRepository.EndSessionAsync();
// Dispose _sessions repository ...
this._sessionsRepository?.Dispose();
this._sessionsRepository = null;
// Dispose google apis service...
this._apisSheetsService?.Dispose();
this._apisSheetsService = null;
// .. and google drive service.
this._apisDriveService.Dispose();
this._apisDriveService = null;
// Dispose live spreadsheets data...
this._spreadsheetsDb.Dispose();
this._spreadsheetsDb = null;
// Dispose google apis user credentials
this._googleApisUser = null;
// Set connection state flag to false.
this.IsConnected = false;
}
// Dispose entire LiveGoogle service
public void Dispose()
{
// Stop available quota execution.
SessionRequestsLimiter.Instance.StopQuotaCount();
// Dispose sessions repository
this._sessionsRepository?.Dispose();
this._sessionsRepository = null;
// Dispose google apis sheets service
this._apisSheetsService?.Dispose();
this._apisSheetsService = null;
// Dispose google apis drive service
this._apisDriveService?.Dispose();
this._apisDriveService = null;
// Dispose spreadsheetsDb together with all its content.
this._spreadsheetsDb?.Dispose();
this._spreadsheetsDb = null;
// Cancel and get rid of user credentials
this._googleApisUser = null;
}
// Business Logic pass through code to Select a Session by ID
public SessionsEntity SelectSessionById(int id)
{
try
{
SessionsEntity returnedEntity;
using (var repository = new SessionsRepository())
{
returnedEntity = repository.SelectById(id);
if (returnedEntity != null)
{
returnedEntity.FeeCap = GetFeeCap(returnedEntity.Fee);
}
}
return(returnedEntity);
}
catch (Exception ex)
{
//Log exception error
_loggingHandler.LogEntry(ExceptionHandler.GetExceptionMessageFormatted(ex), true);
throw new Exception("BusinessLogic:SessionsBusiness::SelectSessionById::Error occured.", ex);
}
}
protected override void SetPacketFields()
{
var otherIdsMessage = SessionsRepository.GetOtherClientsIdsToString(Source);
Packet.SetMessage(otherIdsMessage);
}
protected override void ValidateAndInitializeCommandArguments()
{
Destination = Source;
DestinationSessionId = SessionsRepository.GetSessionId(Source);
}
public SessionsRepositoryTest()
{
_eventsStore = new EventsStore();
_repository = new SessionsRepository(_eventsStore);
}
