public static void Delete(BubbleGroup group)
{
lock (BubbleGroupDatabase.OperationLock)
{
var unifiedGroup = @group as UnifiedBubbleGroup;
if (unifiedGroup != null)
{
DeleteUnified(unifiedGroup);
return;
}
var file = BubbleGroupDatabase.GetLocation(@group);
if (File.Exists(file))
{
File.Delete(file);
}
BubbleGroupSync.RemoveFromSync(@group);
BubbleGroupSync.DeleteBubbleGroupIfHasAgent(@group);
BubbleGroupManager.BubbleGroupsRemove(@group);
}
}
public Task CanAddPartyParticipant(BubbleGroup group, Action<bool> result)
{
return Task.Factory.StartNew(() =>
{
var fullChat = FetchFullChat(group.Address, group.IsExtendedParty);
var partyParticipants = GetPartyParticipants(fullChat);
if (!IsPartOfParty(partyParticipants))
{
result(false);
return;
}
if (ChatAdminsEnabled(group.Address))
{
if (group.IsExtendedParty && IsDemocracyEnabled(group))
{
//if democracy is enabled in a spergroup anyone can add members
result(true);
return;
}
if (!IsAdmin(group.Address, group.IsExtendedParty))
{
result(false);
return;
}
}
result(true);
});
}
public static UnifiedBubbleGroup CreateUnified(List<BubbleGroup> groups, BubbleGroup primaryGroup)
{
lock (BubbleGroupDatabase.OperationLock)
{
var unifiedGroupsToKill = new HashSet<UnifiedBubbleGroup>();
foreach (var group in groups)
{
if (group.IsUnified)
{
unifiedGroupsToKill.Add(group.Unified);
@group.DeregisterUnified();
}
}
foreach (var unifiedGroup in unifiedGroupsToKill)
{
BubbleGroupManager.BubbleGroupsRemove(unifiedGroup);
}
UnifiedBubbleGroupsDatabase.Remove(unifiedGroupsToKill);
var unified = CreateUnifiedInternal(groups, primaryGroup);
UnifiedBubbleGroupsDatabase.Add(unified,
new DisaUnifiedBubbleGroupEntry(unified.ID,
unified.Groups.Select(innerGroup => innerGroup.ID)
.ToArray(), primaryGroup.ID, primaryGroup.ID));
BubbleGroupManager.BubbleGroupsAdd(unified);
return unified;
}
}
public Task UnblockPartyParticipant(BubbleGroup group, DisaParticipant participant, Action<bool> result)
{
return Task.Factory.StartNew(() =>
{
using (var client = new FullClientDisposable(this))
{
try
{
var response = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsKickFromChannelAsync(new ChannelsKickFromChannelArgs
{
Channel = new InputChannel
{
ChannelId = uint.Parse(group.Address),
AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
},
Kicked = false,
UserId = new InputUser
{
UserId = uint.Parse(participant.Address),
AccessHash = GetUserAccessHashIfForeign(participant.Address)
}
}));
result(true);
}
catch (Exception e)
{
DebugPrint("#### Exception " + e);
result(false);
}
}
});
}
internal static void RaiseSyncReset(BubbleGroup group)
{
if (_syncReset != null)
{
_syncReset(group);
}
}
public Task GetPartyBlockedParticipantPicture(BubbleGroup group, string address, Action<DisaThumbnail> result)
{
return Task.Factory.StartNew(() =>
{
result(GetThumbnail(address, false, true));
});
}
internal static void UpdateGroupLegibleID(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service)) return;
try
{
service.GetBubbleGroupLegibleId(bubbleGroup, legibleID =>
{
bubbleGroup.LegibleId = legibleID;
if (finished == null)
{
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group legible ID: " + service.Information.ServiceName + ": " +
ex.Message);
if (finished != null)
{
finished();
}
}
}
private static void InsertDefaultIfNull(BubbleGroup group)
{
lock (_lock)
{
if (group.Settings == null)
{
using (var db = new SqlDatabase<BubbleGroupSettings>(GetPath()))
{
var settings = new BubbleGroupSettings
{
Mute = false,
Unread = true,
Guid = group.ID,
LastUnreadSetTime = 0,
ReadTimes = null,
ParticipantNicknames = null,
NotificationLed = DefaultNotificationLedColor,
VibrateOption = null,
VibrateOptionCustomPattern = null,
Ringtone = null,
};
db.Add(settings);
group.Settings = settings;
}
}
}
}
private List<VisualBubble> LoadBubblesForBubbleGroup(BubbleGroup @group, long fromTime, int max)
{
var response = GetMessageHistory(group, fromTime, max);
var messages = response as MessagesMessages;
var messagesSlice = response as MessagesMessagesSlice;
var messagesChannels = response as MessagesChannelMessages;
if (messages != null)
{
_dialogs.AddChats(messages.Chats);
_dialogs.AddUsers(messages.Users);
//DebugPrint("Messages are as follows " + ObjectDumper.Dump(messages.Messages));
messages.Messages.Reverse();
return ConvertMessageToBubbles(messages.Messages);
}
if (messagesSlice != null)
{
_dialogs.AddChats(messagesSlice.Chats);
_dialogs.AddUsers(messagesSlice.Users);
//DebugPrint("Messages are as follows " + ObjectDumper.Dump(messagesSlice.Messages));
messagesSlice.Messages.Reverse();
return ConvertMessageToBubbles(messagesSlice.Messages);
}
if (messagesChannels != null)
{
_dialogs.AddChats(messagesChannels.Chats);
_dialogs.AddUsers(messagesChannels.Users);
messagesChannels.Messages.Reverse();
var bubbles = ConvertMessageToBubbles(messagesChannels.Messages);
SetExtendedFlag(bubbles);
return bubbles;
}
return new List<VisualBubble>();
}
public static UnifiedBubbleGroup CreateUnified(List<BubbleGroup> groups, BubbleGroup primaryGroup)
{
lock (BubbleGroupDatabase.OperationLock)
{
var unifiedGroupsToKill = new HashSet<UnifiedBubbleGroup>();
foreach (var group in groups)
{
if (group.IsUnified)
{
unifiedGroupsToKill.Add(group.Unified);
@group.DeregisterUnified();
}
}
foreach (var unifiedGroup in unifiedGroupsToKill)
{
BubbleGroupManager.BubbleGroupsRemove(unifiedGroup);
}
BubbleGroupIndex.RemoveUnified(unifiedGroupsToKill.Select(x => x.ID).ToArray());
var unified = CreateUnifiedInternal(groups, primaryGroup);
BubbleGroupIndex.AddUnified(unified);
BubbleGroupManager.BubbleGroupsAdd(unified);
return unified;
}
}
public Task<List<VisualBubble>> LoadBubbles(BubbleGroup @group, long fromTime, int max = 100)
{
return Task<List<VisualBubble>>.Factory.StartNew(() =>
{
return LoadBubblesForBubbleGroup(group, fromTime, max);
});
}
internal static void UpdateName(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service)) return;
try
{
service.GetBubbleGroupName(bubbleGroup, title =>
{
bubbleGroup.IsTitleSetFromService = true;
bubbleGroup.Title = title;
if (finished == null)
{
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
BubbleGroupEvents.RaiseInformationUpdated(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group name: " + service.Information.ServiceName + ": " +
ex.Message);
if (finished != null)
{
finished();
}
}
}
public BubbleGroupFinderResult Find()
{
var groups = new List<BubbleGroup>();
// If a group is still valid for this grid, we don't need to search for it again
// Turns out this is a bad optimisation - needs profiling
//groups.AddRange(_parentGroups.Where(x => x.IsValidFor(_grid)));
for (int y = 0; y < _grid.Height; y++)
{
for (int x = 0; x < _grid.Width; x++)
{
if(!_stats.ContainsKey(_grid[x,y])) _stats.Add(_grid[x,y], 1);
else _stats[_grid[x, y]]++;
if (!groups.Any(group => group.Locations.Contains(new Point(x, y))))
{
_currentGroup = new BubbleGroup();
FindBubbleGroup(x, y);
if (_currentGroup.Locations.Count > 1 && _currentGroup.Colour != Bubble.None)
{
groups.Add(_currentGroup);
}
}
}
}
return new BubbleGroupFinderResult(groups, _stats);
}
public Task GetPartyBlockedParticipants(BubbleGroup group, Action<DisaParticipant[]> result)
{
return Task.Factory.StartNew(() =>
{
var returnList = new List<DisaParticipant>();
var fullChat = FetchFullChat(group.Address, group.IsExtendedParty);
var iChatFull = fullChat.FullChat;
var channelFull = iChatFull as ChannelFull;
if (channelFull != null)
{
var kickedParticipants = GetChannelParticipants(channelFull, new ChannelParticipantsKicked());
foreach (var participant in kickedParticipants)
{
if (participant is ChannelParticipantKicked)
{
var id = TelegramUtils.GetUserIdFromChannelParticipant(participant);
if (id != null)
{
var user = _dialogs.GetUser(uint.Parse(id));
var name = TelegramUtils.GetUserName(user);
returnList.Add(new DisaParticipant(name, id));
}
}
}
}
result(returnList.ToArray());
});
}
public static string GetLocation(BubbleGroup theGroup)
{
var tableLocation = GetServiceLocation(theGroup.Service.Information);
var groupLocation = Path.Combine(tableLocation,
theGroup.Service.Information.ServiceName + "^" + theGroup.ID + ".group");
return groupLocation;
}
public UnifiedBubbleGroup(List<BubbleGroup> groups, BubbleGroup primaryGroup,
VisualBubble initialBubble, string id = null)
: base(initialBubble, id, false)
{
_unifiedService = initialBubble.Service;
Groups = groups;
PrimaryGroup = primaryGroup;
SendingGroup = primaryGroup;
}
public static bool UpdatePhoto(BubbleGroup bubbleGroup, Action<DisaThumbnail> finished)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service))
return false;
if (bubbleGroup.Service.Information.UsesInternet && !Platform.HasInternetConnection())
return false;
try
{
service.GetBubbleGroupPhoto(bubbleGroup, photo =>
{
if (photo != null && photo.Failed)
{
if (finished != null)
{
finished(bubbleGroup.Photo);
}
return;
}
Action<DisaThumbnail> callbackFinished = thePhoto =>
{
bubbleGroup.Photo = thePhoto;
bubbleGroup.IsPhotoSetFromService = true;
if (finished != null)
{
finished(bubbleGroup.Photo);
}
};
if (photo == null && bubbleGroup.IsParty)
{
BubbleGroupUtils.StitchPartyPhoto(bubbleGroup, callbackFinished);
}
else
{
callbackFinished(photo);
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group photo: " +
service.Information.ServiceName + ": " + ex.Message);
if (finished != null)
{
finished(null);
}
}
return true;
}
public static void BubbleGroupsAdd(BubbleGroup group, bool initialLoad = false)
{
lock (BubbleGroupsLock)
{
BubbleGroups.Add(group);
if (!initialLoad && !(group is UnifiedBubbleGroup))
{
BubbleGroupIndex.Add(group);
}
}
}
private static BubbleGroupCache Generate(BubbleGroup group, string guid)
{
var bubbleGroupCache = new BubbleGroupCache
{
Name = group.Title,
Photo = group.Photo,
Participants = group.Participants.ToList(),
Guid = guid,
};
return bubbleGroupCache;
}
private static void Bind(BubbleGroup associatedGroup, BubbleGroupCache item)
{
associatedGroup.Title = item.Name;
associatedGroup.Photo = item.Photo;
associatedGroup.IsPhotoSetInitiallyFromCache = true;
if (item.Participants != null)
{
associatedGroup.Participants = new ThreadSafeList<DisaParticipant>(item.Participants);
foreach (var participant in associatedGroup.Participants)
{
participant.IsPhotoSetInitiallyFromCache = true;
}
}
}
public Task CanConvertToExtendedParty(BubbleGroup group, Action<bool> result)
{
return Task.Factory.StartNew(() =>
{
if (!group.IsExtendedParty && IsCreator(group.Address, group.IsExtendedParty))
{
result(true);
}
else
{
result(false);
}
});
}
public Task CanSetPartyAllMembersAdministratorsRestriction(BubbleGroup group, Action<bool> result)
{
return Task.Factory.StartNew(() =>
{
if (!group.IsExtendedParty && IsCreator(group.Address, group.IsExtendedParty))
{
result(true);
}
else
{
result(false);
}
});
}
public Task HasPartyDescription(BubbleGroup group, Action<bool> result)
{
return Task.Factory.StartNew(() =>
{
var channel = _dialogs.GetChat(uint.Parse(group.Address)) as Channel;
if (channel != null)
{
result(true);
}
else
{
result(false);
}
});
}
public static string GetUnreadIndicatorGuid(BubbleGroup group)
{
InsertDefaultIfNull(group);
var guid = group.Settings.UnreadIndicatorGuid;
if (!string.IsNullOrWhiteSpace(guid))
{
var indexOf = guid.IndexOf('|');
if (indexOf > -1)
{
var editedGuid = guid.Substring(0, indexOf);
return editedGuid;
}
}
return guid;
}
public Task GetPartyDescription(BubbleGroup group, Action<string> result)
{
return Task.Factory.StartNew(() =>
{
var fullChat = FetchFullChat(group.Address, true);
var fullChannel = fullChat?.FullChat as ChannelFull;
if (fullChannel != null)
{
result(fullChannel.About);
}
else
{
result(null);
}
});
}
protected internal void OnBubbleUpdated(VisualBubble bubble, BubbleGroup group)
{
if (Bubbles.Count > BubblesCapSize)
{
Bubbles.RemoveAt(0);
}
var addedToEnd = false;
for (int i = Bubbles.Count - 1; i >= 0; i--)
{
var nBubble = Bubbles[i];
if (nBubble.Time <= bubble.Time)
{
// adding it to the end, we can do a simple contract
if (i == Bubbles.Count - 1)
{
addedToEnd = true;
Bubbles.Add(bubble);
if (bubble.Direction == Bubble.BubbleDirection.Incoming)
{
BubbleGroupSettingsManager.SetUnread(this, true);
}
}
// inserting, do a full contract
else
{
Bubbles.Insert(i + 1, bubble);
}
break;
}
// could not find a valid place to insert, then skip insertion.
if (i == 0)
{
return;
}
}
if (SendingGroup != group && addedToEnd)
{
SendingGroup = group;
BubbleGroupEvents.RaiseSendingServiceChange(this);
}
RaiseBubbleInserted(bubble);
}
private static bool HasNotQueued(BubbleGroup group)
{
lock (_dbLock)
{
var groupId = group.ID;
using (var db = new SqlDatabase<NotQueuedEntry>(NotQueuedLocation))
{
// don't add a duplicate group into the queue
foreach (var possibleGroup in db.Store.Where(x =>
x.BubbleGroupGuid == groupId))
{
return true;
}
}
return false;
}
}
internal static void RollBackTo(BubbleGroup group, long index)
{
if (index <= 0)
{
throw new ArgumentException("Index can't be <= 0!");
}
var groupDatabaseLocation = GetLocation(@group);
using (var stream = File.Open(groupDatabaseLocation, FileMode.Open, FileAccess.ReadWrite))
{
if (index > stream.Length)
{
throw new Exception("File length can't be greater than index.");
}
stream.SetLength(index);
}
}
public Task<BubbleGroupSync.Result> Sync(BubbleGroup @group, string actionId)
{
return Task<BubbleGroupSync.Result>.Factory.StartNew(() =>
{
const int limit = 100;
var actionIdLong = actionId == null ? 0 : long.Parse(actionId);
if (actionIdLong == 0)
{
var bubbles = LoadBubblesForBubbleGroup(group, Time.GetNowUnixTimestamp(), limit);
if (bubbles.LastOrDefault() != null)
{
var lastActionId = bubbles.LastOrDefault().IdService;
return new BubbleGroupSync.Result(BubbleGroupSync.Result.Type.Purge,lastActionId,null,bubbles.ToArray());
}
}
return new BubbleGroupSync.Result();
});
}
internal static async void UpdateName(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service)) return;
try
{
await service.GetBubbleGroupName(bubbleGroup, title =>
{
bubbleGroup.IsTitleSetFromService = true;
if (string.IsNullOrWhiteSpace(title))
{
Utils.DebugPrint("Update name title is null (rejecting): " + service.Information.ServiceName +
" - " + bubbleGroup.Address);
}
else
{
bubbleGroup.Title = title;
}
if (finished == null)
{
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
BubbleGroupEvents.RaiseInformationUpdated(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group name: " + service.Information.ServiceName +
" - " + bubbleGroup.Address + ": " + ex);
if (finished != null)
{
finished();
}
}
}
public override bool SwitchCurrentBubbleGroupOnUI(BubbleGroup group)
{
throw new NotImplementedException();
}
public Task InviteToChannel(BubbleGroup group, Tuple <Contact, Contact.ID>[] contacts, Action <bool> result)
{
var addPartyResult = AddPartyResult.Success;
return(Task.Factory.StartNew(() =>
{
if (contacts.Length > 0)
{
var inputUsers = new List <IInputUser>();
var names = new List <string>();
foreach (var contact in contacts)
{
names.Add(contact.Item1.FullName);
IUser user = null;
if (contact.Item1 is TelegramContact)
{
user = (contact.Item1 as TelegramContact).User;
}
else if (contact.Item1 is TelegramBotContact)
{
user = (contact.Item1 as TelegramBotContact).User;
}
var inputUser = TelegramUtils.CastUserToInputUser(user);
if (inputUser != null)
{
inputUsers.Add(inputUser);
}
}
if (inputUsers.Any())
{
using (var client = new FullClientDisposable(this))
{
try
{
var update = TelegramUtils.RunSynchronously(client.Client.Methods.ChannelsInviteToChannelAsync(new ChannelsInviteToChannelArgs
{
Channel = new InputChannel
{
ChannelId = uint.Parse(group.Address),
AccessHash = TelegramUtils.GetChannelAccessHash(_dialogs.GetChat(uint.Parse(group.Address)))
},
Users = inputUsers
}));
SendToResponseDispatcher(update, client.Client);
}
catch (Exception ex)
{
Utils.DebugPrint("Failed Telegram ChannelsInviteToChannelAsync: " + ex);
if (ex.Message.Contains("PEER_FLOOD"))
{
_addPartyResult = AddPartyResult.Flood;
}
else
{
_addPartyResult = AddPartyResult.Error;
}
return;
}
}
}
}
}));
}
