protected override void OnCreated()
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
Group noneGroup = new Group()
{
Id = -1, GroupName = "None"
};
GroupsList = new BindableCollection <Group>(dataContext.Table <Group>().OrderBy(g => g.GroupName).ToList());
GroupsList.Insert(0, noneGroup);
if (!IsAdding)
{
var client = dataContext.Table <Client>().First(x => x.Id == ClientId);
Forename = client.Forename;
Surname = client.Surname;
Birthdate = client.Birthdate;
Latitude = client.Latitude;
Longitude = client.Longitude;
IsActive = client.IsActive;
Group = client.Group ?? noneGroup;
Photo = IsoStorageHelper.PhotoFromFile(client.Photo);
}
else
{
IsActive = true;
Group = noneGroup;
}
}
}
protected override void LoadState()
{
Forename = (string)TombstoningContainer.GetValue(TombstoningVariables.ClientEditForename);
Surname = (string)TombstoningContainer.GetValue(TombstoningVariables.ClientEditSurname);
Birthdate = (DateTime?)TombstoningContainer.GetValue(TombstoningVariables.ClientEditBirthdate);
Longitude = (double?)TombstoningContainer.GetValue(TombstoningVariables.ClientEditLongitude);
Latitude = (double?)TombstoningContainer.GetValue(TombstoningVariables.ClientEditLatitude);
IsActive = (bool)TombstoningContainer.GetValue(TombstoningVariables.ClientEditIsActive);
lastPhotoName = (string)TombstoningContainer.GetValue(TombstoningVariables.ClientEditLastPhotoName);
Photo = ImageConverter.ConvertToImage((byte[])TombstoningContainer.GetValue(TombstoningVariables.ClientEditPhoto));
using (IDataContextWrapper dataContext = _dataContextLocator())
{
Group noneGroup = new Group()
{
Id = -1, GroupName = "None"
};
GroupsList = new BindableCollection <Group>(dataContext.Table <Group>().OrderBy(g => g.GroupName).ToList());
GroupsList.Insert(0, noneGroup);
long id = (long)TombstoningContainer.GetValue(TombstoningVariables.ClientEditGroupId);
Group = GroupsList.FirstOrDefault(x => x.Id == id) ?? noneGroup;
}
PhotoChooserTask photoChooserTask = new PhotoChooserTask();
photoChooserTask.Completed += getPhotoComplete;
}
public void Setup()
{
_mockRecipeDataContext = new Mock <IRecipeDataContext>();
_stubDataContextWrapper = new StubDataContextWrapper(_mockRecipeDataContext.Object);
_recipeRepository = new RecipeRepository(_stubDataContextWrapper);
var recipe1 = new Recipe
{
recipe_id = 1, recipe_name = "Potato", cooking_time = new TimeSpan(00, 30, 00), ingredients = "Potato",
description = "Cook", is_favorite = false
};
var recipe2 = new Recipe
{
recipe_id = 2, recipe_name = "Chicken", cooking_time = new TimeSpan(00, 20, 00),
ingredients = "Chicken", description = "Boil", is_favorite = false
};
var recipe3 = new Recipe
{
recipe_id = 3, recipe_name = "Salad", cooking_time = new TimeSpan(00, 15, 00),
ingredients = "Cucumber - 1\nTomato - 1", description = "Cut", is_favorite = false
};
var recipes = new List <Recipe> {
recipe1, recipe2, recipe3
};
_mockRecipeDataContext.Setup(x => x.Recipes()).Returns(new StubRecipeTable(recipes));
}
public BottleDescriptionRepository(
IDataContextWrapper dataContext,
IMapper mapper)
{
this.dataContext = dataContext;
this.mapper = mapper;
}
public BottleRepository(
IDataContextWrapper context,
IMapper mapper)
{
this.context = context;
this.mapper = mapper;
}
public SignInManagerWrapper(
SignInManager <User> signInManager,
IDataContextWrapper dataContext
)
{
this.signInManager = signInManager;
this.dataContext = dataContext;
}
public TransactionRepository(
IDataContextWrapper dataContext,
IMapper mapper
)
{
this.dataContext = dataContext;
this.mapper = mapper;
}
public EventRepository(IDataContextWrapper dataContext, IEventPlayerRepository eventPlayerRepo, IMatchRepository matchRepo, IPlayerRepository playerRepo, IRoundPrizeRepository roundPrizeRepository)
{
_dataContext = dataContext;
_eventPlayerRepository = eventPlayerRepo;
_matchRepository = matchRepo;
_playerRepository = playerRepo;
_roundPrizeRepository = roundPrizeRepository;
}
public UserRepository(
IDataContextWrapper context,
IUserManagerWrapper userManager,
IMapper mapper)
{
this.context = context;
this.userManager = userManager;
this.mapper = mapper;
}
private void ChangeActiveStatus(Client client, bool isActive)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
var clientEntity = dataContext.Table <Client>().First(x => x.Id == client.Id);
clientEntity.IsActive = isActive;
dataContext.SubmitChanges();
}
}
public void Create_ExistingEmail_Exception(
IDataContextWrapper db,
CustomerCreate data,
CustomerManager sut)
{
data.Email = db.Set <Customer>().Select(x => x.Email).First();
Assert.Throws <CustomerManager.EmailAlreadyExistsException>(() =>
sut.Create(data));
}
protected override void OnCreated()
{
base.OnCreated();
using (IDataContextWrapper dataContext = _dataContextLocator())
GroupName = dataContext.Table <Group>().First(g => g.Id == GroupId).GroupName;
RefreshClients();
SelectedClient = ClientsList.FirstOrDefault();
}
public void AddClientToGroup(Group group)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
if (dataContext.Table <Client>().Where(c => c.GroupId == null).Count() == 0)
{
MessageBox.Show("There are no clients without a group.");
return;
}
_navigationService.UriFor <GroupAddClientViewModel>().WithParam(g => g.GroupId, group.Id).Navigate();
}
public void RemoveClientFromGroup(Client client)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
var clientRecord = dataContext.Table <Client>().FirstOrDefault(x => x.Id == client.Id);
clientRecord.Group.Clients.Remove(clientRecord); //automatically detach client from group
dataContext.SubmitChanges();
}
Groups.First(x => x.Id == client.GroupId).Clients.Remove(client);
}
public void Delete(Client client)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
var clientEntity = dataContext.Table <Client>().First(x => x.Id == client.Id);
IsoStorageHelper.DeleteFile(clientEntity.Photo);
dataContext.DeleteOnSubmit(clientEntity);
dataContext.SubmitChanges();
}
Clients.Remove(client);
}
protected override void OnActivate()
{
base.OnActivate();
using (IDataContextWrapper dataContext = _dataContextLocator())
{
Client client = dataContext.Table <Client>().FirstOrDefault(x => x.Id == ClientID);
if (client != null)
{
FullName = client.FullName;
Photo = IsoStorageHelper.PhotoFromFile(client.Photo);
}
}
}
public void DeleteGroup(Group group)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
Group groupRecord = dataContext.Table <Group>().FirstOrDefault(x => x.Id == group.Id);
dataContext.DeleteOnSubmit(groupRecord);
dataContext.Table <Client>().Apply(x => { if (x.GroupId == group.Id)
{
x.Group = null;
}
});
dataContext.SubmitChanges();
}
Groups.Remove(group);
}
public void Add()
{
if (SelectedClient != null)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
Group group = dataContext.Table <Group>().First(g => g.Id == GroupId);
dataContext.Table <Client>().First(c => c.Id == SelectedClient.Id).Group = group;
dataContext.SubmitChanges();
}
GoBack();
}
else
{
MessageBox.Show("Client must be selected.");
}
}
private void RefreshClients(System.Action callback = null)
{
//potentially time consuming loading
Task.Run(() =>
{
lock (_syncRoot)
{
Clients.Clear();
}
using (IDataContextWrapper dataContext = _dataContextLocator())
{
var clientsList = dataContext.Table <Client>().AsEnumerable();
clientsList.Apply(c =>
{
if (c.Longitude != null && c.Latitude != null)
{
c.Distance = geoLocation.CalculateDistance(currentPosition, (double)c.Latitude, (double)c.Longitude);
}
});
if (BeginDate.Ticks > 0)
{
clientsList = clientsList.Where(c => c.Birthdate >= BeginDate);
}
if (EndDate.Ticks > 0)
{
clientsList = clientsList.Where(c => c.Birthdate <= EndDate);
}
if (Distance < Int32.MaxValue)
{
clientsList = clientsList.Where(c => c.Distance <= Distance);
}
lock (_syncRoot)
{
Clients = new BindableCollection <Client>(clientsList);
if (callback != null)
{
callback();
}
}
}
});
}
public void Save()
{
if (!string.IsNullOrWhiteSpace(GroupName))
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
dataContext.InsertOnSubmit(new Group()
{
GroupName = this.GroupName
});
dataContext.SubmitChanges();
}
GoBack();
}
else
{
MessageBox.Show("Group must have GroupName");
}
}
private void RefreshClients(string searchPhrase = null)
{
//potentially time consuming loading
Task.Run(() =>
{
lock (_syncRoot)
{
Clients.Clear();
_currentSearchPhrase = searchPhrase;
}
using (IDataContextWrapper dataContext = _dataContextLocator())
{
DataLoadOptions options = new DataLoadOptions();
options.LoadWith <Client>(c => c.Group);
dataContext.LoadOptions = options;
BindableCollection <Client> clientsList;
if (searchPhrase != null)
{
clientsList = new BindableCollection <Client>(dataContext.Table <Client>()
.Where(x => x.Surname.Contains(searchPhrase) || x.Forename.Contains(searchPhrase))
.ToList()
.OrderBy(c => c.FullName));
}
else
{
clientsList = new BindableCollection <Client>(dataContext.Table <Client>().ToList().OrderBy(c => c.FullName));
}
lock (_syncRoot)
{
if (searchPhrase == _currentSearchPhrase)
{
Clients = clientsList;
}
}
}
});
}
private void RefreshGroups()
{
Task.Run(() =>
{
lock (_syncRoot)
{
using (IDataContextWrapper dataContext = _dataContextLocator())
{
Groups.Clear();
DataLoadOptions options = new DataLoadOptions();
options.LoadWith <Group>(g => g.Clients);
dataContext.LoadOptions = options;
dataContext.Table <Group>()
.OrderBy(x => x.GroupName)
.ToList()
.ForEach(g => Groups.Add(g));
}
}
});
}
public void Setup()
{
_mockEmployeeDataContext = new Mock <IEmployeeDataContext>();
_stubDataContextWrapper = new StubDataContextWrapper(_mockEmployeeDataContext.Object);
_employeeRepository = new EmployeeRepository(_stubDataContextWrapper);
var employee1 = new EmployeeEntity {
Id = 1, FirstName = "John", LastName = "Smith", StartDate = new DateTime(2013, 01, 10)
};
var employee2 = new EmployeeEntity {
Id = 2, FirstName = "Frank", LastName = "Smith", StartDate = new DateTime(2013, 01, 15)
};
var employee3 = new EmployeeEntity {
Id = 3, FirstName = "Stan", LastName = "Johnson", StartDate = new DateTime(2013, 01, 20)
};
var employees = new List <EmployeeEntity> {
employee1, employee2, employee3
};
_mockEmployeeDataContext.Setup(x => x.Employees()).Returns(new StubEmployeeTable(employees));
}
private void UpdateConversation(MessageModel message, IDataContextWrapper context)
{
// Update the conversation object corresponding to the message
MessageModel existingConversation = null;
IQueryable<MessageModel> existingConversationIQueryable = null;
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start find existing conversation"));
if (message.ConversationId != Guid.Empty && existingConversation == null)
{
existingConversationIQueryable = from m in context.Table<MessageModel>()
where m.ConversationId == message.ConversationId && m.MessageType == MessageType.Conversation
select m;
existingConversation = existingConversationIQueryable.FirstOrDefault<MessageModel>();
if (existingConversation != null)
{
if (existingConversation.LastUpdateTime < message.LastUpdateTime)
{
existingConversation.LastUpdateTime = message.LastUpdateTime;
existingConversation.TextMessage = message.TextMessage;
}
if (existingConversation.LastReadTime.Ticks < message.LastUpdateTime.Ticks)
{
if (!existingConversation.UnreadCount.HasValue || message.Sender.Id == this.userSettings.Me.Id)
{
existingConversation.UnreadCount = 0;
}
else
{
existingConversation.UnreadCount = existingConversation.UnreadCount.Value + 1;
}
}
}
else
{
existingConversation = new MessageModel(message);
existingConversation.MessageId = Guid.Empty;
existingConversation.ClientMessageId = Guid.Empty;
existingConversation.MessageType = MessageType.Conversation;
existingConversation.MessageFlags = 0;
existingConversation.Image = null;
existingConversation.LastUpdateTime = message.LastUpdateTime;
existingConversation.TextMessage = message.TextMessage;
existingConversation.LastReadTime = new DateTime(1970, 1, 1);
existingConversation.UnreadCount = 1;
context.InsertOnSubmit<MessageModel>(existingConversation);
}
}
}
private void SaveSingleTaskMessage(MessageModel message, List<UserModel> users, IDataContextWrapper context = null)
{
if (context == null)
{
context = this.dataContext;
}
MessageModel taskInfoMessage = null;
lock (this)
{
try
{
if (!message.IsTaskMessage.Value)
{
return;
}
// Add the sender/recipient if they are not inthe contact list already
if (!this.ContainsContact(message.Sender) && !users.Contains(message.Sender))
{
this.AddContact(message.Sender, users);
users.Add(message.Sender);
}
if (!this.ContainsContact(message.Recipient) && !users.Contains(message.Recipient))
{
this.AddContact(message.Recipient, users);
users.Add(message.Recipient);
}
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "end find existing conversation"));
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start find existing message"));
// Task exists
// Task exists and deleted
// Task doesn't exist
// If the message already exists, delete it and reinsert it
// The reason is that the server version is more authoritative.
IQueryable<MessageModel> existingInfoMessageQuery = from m in context.Table<MessageModel>()
where
(m.TaskId == message.ClientMessageId)
select m;
taskInfoMessage = existingInfoMessageQuery.FirstOrDefault<MessageModel>();
bool shouldInsertTaskInfoMessage = false;
if (taskInfoMessage == null)
{
shouldInsertTaskInfoMessage = true;
taskInfoMessage = new MessageModel();
taskInfoMessage.ConversationId = message.ConversationId;
taskInfoMessage.MessageId = message.MessageId;
taskInfoMessage.ClientMessageId = Guid.NewGuid();
taskInfoMessage.Sender = message.Sender;
taskInfoMessage.Recipient = message.Recipient;
taskInfoMessage.SenderId = taskInfoMessage.Sender.Id;
taskInfoMessage.RecipientId = taskInfoMessage.Recipient.Id;
taskInfoMessage.MessageType = MessageType.Message;
taskInfoMessage.MessageFlags = MessageFlags.TaskInfo;
taskInfoMessage.TaskId = message.ClientMessageId;
}
taskInfoMessage.PostDateTimeUtcTicks = message.PostDateTimeUtcTicks;
taskInfoMessage.ClientVisibleTimeTicks = DateTime.UtcNow.Ticks;
taskInfoMessage.LastReadTime = new DateTime(1970, 1, 1);
taskInfoMessage.LastUpdateTime = DateTime.Now;
// If the message already exists, delete it and reinsert it
// The reason is that the server version is more authoritative.
IQueryable<MessageModel> existingMessages = from m in context.Table<MessageModel>()
where
(m.ClientMessageId == message.ClientMessageId)
select m;
MessageModel existingMessage = existingMessages.FirstOrDefault<MessageModel>();
if (existingMessage != null && (!message.IsTaskDeleted.HasValue || !message.IsTaskDeleted.Value))
{
if (existingMessage.PostDateTimeUtcTicks > message.PostDateTimeUtcTicks)
{
return;
}
existingMessage.PostDateTimeUtcTicks = message.PostDateTimeUtcTicks - 1;
if (message.Sender.Id != this.userSettings.Me.Id)
{
existingMessage.ClientVisibleTimeTicks = DateTime.UtcNow.Ticks;
}
if (message.Sender.Id == this.userSettings.Me.Id)
{
existingMessage.LastReadTime = (new DateTime(message.PostDateTimeUtcTicks, DateTimeKind.Utc)).ToLocalTime();
}
existingMessage.TaskName = message.TaskName;
//existingMessage.IsCompleted = message.IsCompleted;
if (existingMessage.RecipientId == 0)
{
existingMessage.RecipientId = message.RecipientId;
}
existingMessage.LastTaskUpdaterId = message.SenderId;
taskInfoMessage.TextMessage = taskInfoMessage.SenderId == UserSettingsModel.Instance.Me.Id ? string.Format(Strings.YouUpdatedTask, message.TaskName, message.Sender.Name) : string.Format(Strings.HasUpdatedTask, message.Sender.Name, message.TaskName);
foreach (var m in message.TaskItemList)
{
IQueryable<MessageModel> existingTaskItemQuery = from item in context.Table<MessageModel>()
where
(item.ClientMessageId == m.ClientMessageId)
select item;
MessageModel existingTaskItem = existingTaskItemQuery.FirstOrDefault<MessageModel>();
if (m.IsTaskDeleted.HasValue && m.IsTaskDeleted.Value)
{
if (existingTaskItem != null)
{
context.DeleteOnSubmit<MessageModel>(existingTaskItem);
}
continue;
}
if (existingTaskItem == null)
{
m.LastReadTime = new DateTime(1970, 1, 1);
m.PollMessageId = message.ClientMessageId;
m.MessageType = MessageType.Message;
context.InsertOnSubmit<MessageModel>(m);
continue;
}
existingTaskItem.ClientVisibleTimeTicks = DateTime.UtcNow.Ticks;
if (0 != string.Compare(existingTaskItem.TaskName, m.TaskName, StringComparison.OrdinalIgnoreCase) ||
existingTaskItem.IsCompleted != m.IsCompleted)
{
existingTaskItem.TaskName = m.TaskName;
existingTaskItem.IsCompleted = m.IsCompleted;
existingTaskItem.LastTaskUpdaterId = message.SenderId;
}
if (0 != StringComparer.OrdinalIgnoreCase.Compare(existingTaskItem.ItemOrder, m.ItemOrder))
{
existingTaskItem.ItemOrder = m.ItemOrder;
}
}
}
else if (existingMessage != null)
{
if (existingMessage.TaskItemList != null)
{
foreach (var m in existingMessage.TaskItemList)
{
context.Attach<MessageModel>(m);
context.DeleteOnSubmit<MessageModel>(m);
}
}
context.DeleteOnSubmit<MessageModel>(existingMessage);
taskInfoMessage.TextMessage = taskInfoMessage.SenderId == UserSettingsModel.Instance.Me.Id ? string.Format(Strings.YouDeletedTask, message.TaskName, message.Sender.Name) : string.Format(Strings.HasDeletedTask, message.Sender.Name, existingMessage.TaskName, message.TaskName);
}
else if (existingMessage == null && message.IsTaskDeleted.HasValue && message.IsTaskDeleted.Value)
{
taskInfoMessage.TextMessage = taskInfoMessage.SenderId == UserSettingsModel.Instance.Me.Id ? string.Format(Strings.YouDeletedTask, message.TaskName, message.Sender.Name) : string.Format(Strings.HasDeletedTask, message.Sender.Name, existingMessage.TaskName, message.TaskName);
}
else if (existingMessage == null && (!message.IsTaskDeleted.HasValue || !message.IsTaskDeleted.Value))
{
message.ClientVisibleTimeTicks = DateTime.UtcNow.Ticks;
message.ConversationId = Guid.Empty;
message.MessageId = Guid.NewGuid();
message.LastReadTime = new DateTime(1970, 1, 1);
context.InsertOnSubmit<MessageModel>(message);
if (message.TaskItemList != null)
{
foreach (var m in message.TaskItemList)
{
if (m.ClientMessageId != Guid.Parse("bbaf9b96-b875-4a23-97ac-77912ca74832"))
{
m.LastReadTime = new DateTime(1970, 1, 1);
context.InsertOnSubmit<MessageModel>(m);
}
}
}
taskInfoMessage.TextMessage = taskInfoMessage.SenderId == UserSettingsModel.Instance.Me.Id ? string.Format(Strings.YouSharedTask, message.TaskName, message.Sender.Name) : string.Format(Strings.HasSharedTask, message.Sender.Name, message.TaskName);
}
if (shouldInsertTaskInfoMessage)
{
//context.InsertOnSubmit<MessageModel>(taskInfoMessage);
//this.UpdateConversation(taskInfoMessage, context);
}
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "end find existing message"));
context.SubmitChanges();
}
catch (Exception ex)
{
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "Error in DataSync::SaveSingleTaskMessage for task ", message.TaskName));
this.dataContext.Dispose();
this.dataContext = new DataContextWrapper<YapperDataContext>();
}
}
Messenger.Default.Send<NewMessageEvent>(new NewMessageEvent() { Message = taskInfoMessage, IsPush = false });
}
private void SaveSingleMessage(MessageModel message, List<UserModel> users, IDataContextWrapper context = null)
{
if (context == null)
{
context = this.dataContext;
}
lock (this)
{
try
{
if (message.IsImage)
{
this.WriteImageToIsoStorage(message.MessageId, message.Image);
}
// Add the sender/recipient if they are not inthe contact list already
if (!this.ContainsContact(message.Sender) && !users.Contains(message.Sender))
{
this.AddContact(message.Sender, users);
users.Add(message.Sender);
}
if (!this.ContainsContact(message.Recipient) && !users.Contains(message.Recipient))
{
this.AddContact(message.Recipient, users);
users.Add(message.Recipient);
}
this.UpdateConversation(message, context);
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "end find existing conversation"));
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start find existing message"));
// If the message already exists, delete it and reinsert it
// The reason is that the server version is more authoritative.
IQueryable<MessageModel> existingMessages = from m in context.Table<MessageModel>()
where
(m.ConversationId == message.ConversationId && m.MessageId == message.MessageId) ||
(m.ClientMessageId == message.ClientMessageId && m.MessageId == Guid.Empty)
select m;
// Delete the message only if it's a quick send message
// otherwise update it
MessageModel existingMessage = existingMessages.FirstOrDefault<MessageModel>();
if (existingMessage != null && existingMessage.MessageId == Guid.Empty)
{
message.LastReadTime = existingMessage.LastReadTime;
if (message.IsPollMessage)
{
message.MyPollResponse = existingMessage.MyPollResponse;
}
message.ClientVisibleTimeTicks = existingMessage.ClientVisibleTimeTicks;
context.DeleteOnSubmit(existingMessage);
existingMessage = null;
}
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "end find existing message"));
// Insert it only if the existing message is null
if (existingMessage == null)
{
context.InsertOnSubmit<MessageModel>(message);
}
context.SubmitChanges();
}
catch (Exception ex)
{
this.dataContext.Dispose();
this.dataContext = new DataContextWrapper<YapperDataContext>();
}
}
}
private void SavePollResponse(MessageModel message, IDataContextWrapper context = null)
{
if (context == null)
{
context = this.dataContext;
}
lock (this)
{
try
{
// If this is a poll response message, update the last update time for the poll message
if (message.IsPollResponseMessage && message.IsMine && message.PollMessageId.HasValue)
{
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start update my poll response"));
MessageModel pollMessage = this.GetMessage(message.PollMessageId.Value);
if (pollMessage != null && pollMessage.LastUpdateTime < message.LastUpdateTime)
{
pollMessage.LastUpdateTime = message.LastUpdateTime;
}
if (pollMessage != null)
{
pollMessage.MyPollResponse = message.PollResponse;
}
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start update my poll response"));
}
if (message.IsPollResponseMessage && !message.IsGroup && !message.IsMine && message.PollMessageId.HasValue)
{
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start update other poll response"));
MessageModel pollMessage = this.GetMessage(message.PollMessageId.Value);
if (pollMessage != null && pollMessage.LastUpdateTime < message.LastUpdateTime)
{
pollMessage.LastUpdateTime = message.LastUpdateTime;
}
if (pollMessage != null)
{
pollMessage.OtherPollResponse = message.PollResponse;
}
Debug.WriteLine(string.Format("{0} {1} {2}", DateTime.Now.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "DataSync::MessagesDownloaded", "start update other poll response"));
}
this.UpdateConversation(message, context);
var existingMessages = from m in context.Table<MessageModel>()
where
(m.ConversationId == message.ConversationId && m.MessageId == message.MessageId) ||
(m.ConversationId == message.ConversationId && m.ClientMessageId == message.ClientMessageId && m.MessageId == Guid.Empty)
select m;
// Delete the message only if it's a quick send message
// otherwise update it
MessageModel existingMessage = existingMessages.FirstOrDefault<MessageModel>();
if (existingMessage != null && existingMessage.MessageId == Guid.Empty)
{
message.LastReadTime = existingMessage.LastReadTime;
message.ClientVisibleTimeTicks = existingMessage.ClientVisibleTimeTicks;
context.DeleteOnSubmit(existingMessage);
existingMessage = null;
}
if (existingMessage == null)
{
context.InsertOnSubmit<MessageModel>(message);
}
context.SubmitChanges();
}
catch (Exception ex)
{
this.dataContext.Dispose();
this.dataContext = new DataContextWrapper<YapperDataContext>();
}
}
}
public void RefreshClients()
{
using (IDataContextWrapper dataContext = _dataContextLocator())
ClientsList = new BindableCollection <Client>(dataContext.Table <Client>().Where(c => c.GroupId == null).ToList().OrderBy(c => c.FullName));
}
public EventPlayerRepository(IDataContextWrapper dataContext)
{
_dataContext = dataContext;
}
public EmployeeRepository(IDataContextWrapper dataContextWrapper)
{
_dataContextWrapper = dataContextWrapper;
}
public RoundPrizeRepository(IDataContextWrapper dataContext)
{
_dataContext = dataContext;
}
public void Create_ExistingEmail_Exception(
IDataContextWrapper db,
CustomerCreate data,
CustomerManager sut)
{
data.Email = db.Set<Customer>().Select(x => x.Email).First();
Assert.Throws<CustomerManager.EmailAlreadyExistsException>(() =>
sut.Create(data));
}
public RecipeRepository(IDataContextWrapper dataContextWrapper)
{
_dataContextWrapper = dataContextWrapper;
}
/// <summary>
/// Get the list of users from local db
/// </summary>
/// <returns></returns>
public UserModel GetUser(int userId, IDataContextWrapper context = null)
{
if (context == null)
{
context = this.dataContext;
}
lock (this)
{
if (this.userCache.ContainsKey(userId))
{
return this.userCache[userId];
}
var dbUsers = from u in context.Table<UserModel>()
where u.Id == userId
select u;
if (dbUsers.Count<UserModel>() > 0)
{
UserModel user = dbUsers.FirstOrDefault<UserModel>();
this.userCache.Add(user.Id, user);
return user;
}
return null;
}
}
public PlayerPrizeRepository(IDataContextWrapper dataContext)
{
_dataContext = dataContext;
}
public GameLog(IDataContextWrapper dataContext)
{
_dataContext = dataContext;
}
