private static void HandleStorePurchaseError(BackendResult <StorePurchaseResult, ResultCode> result, Action callback = null)
{
ResultCode resultCode = result.ResultCode;
switch (resultCode)
{
case ResultCode.Succeeded:
if (result.ResultData != null && result.ResultData.state < 0)
{
Execute.ExecuteOnUIThread((Action)(() => new GenericInfoUC(2000).ShowAndHideLater(result.ResultData.error_message ?? CommonResources.UnableToCompletePurchase, null)));
break;
}
break;
case ResultCode.ValidationCancelledOrFailed:
return;
case ResultCode.ConfirmationCancelled:
return;
case ResultCode.BalanceRefillCancelled:
return;
default:
GenericInfoUC.ShowBasedOnResult((int)resultCode, "", (VKRequestsDispatcher.Error)null);
break;
}
if (callback == null)
{
return;
}
callback();
}
private void PurchaseVotesPackWithMobile(VotesPack votesPack, Action successCallback, Action <BackendResult <StorePurchaseResult, ResultCode> > errorCallback)
{
this.BuyVotes(new StoreBuyProductParams(StoreProductType.votes, votesPack.ProductId), (Action <BackendResult <StorePurchaseResult, ResultCode> >)(result =>
{
if (result.ResultCode == ResultCode.Succeeded)
{
Action action = successCallback;
if (action == null)
{
return;
}
action();
}
else
{
Action <BackendResult <StorePurchaseResult, ResultCode> > action = errorCallback;
if (action == null)
{
return;
}
BackendResult <StorePurchaseResult, ResultCode> backendResult = result;
action(backendResult);
}
}));
}
private void PurchaseVotesPackWithInApps(VotesPack votesPack, Action successCallback, Action <BackendResult <StorePurchaseResult, ResultCode> > errorCallback, Action cancelledCallback)
{
InAppPurchaseService.RequestProductPurchase(votesPack.MerchantProductId, (Action <InAppProductPurchaseResult>)(purchaseResult =>
{
switch (purchaseResult.Status)
{
case InAppProductPurchaseStatus.Cancelled:
Action action1 = cancelledCallback;
if (action1 == null)
{
break;
}
action1();
break;
case InAppProductPurchaseStatus.Purchased:
this.FulfillPurchases(votesPack.MerchantProductId, successCallback, errorCallback);
break;
case InAppProductPurchaseStatus.Error:
Action <BackendResult <StorePurchaseResult, ResultCode> > action2 = errorCallback;
if (action2 == null)
{
break;
}
BackendResult <StorePurchaseResult, ResultCode> backendResult = new BackendResult <StorePurchaseResult, ResultCode>(ResultCode.Succeeded, StorePurchaseResult.GetForFailedPurchaseState());
action2(backendResult);
break;
}
}));
}
public void ReorderProducts(int productId, int after = 0, int before = 0, Action <BackendResult <bool, ResultCode> > callback = null)
{
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{
"type",
"stickers"
},
{
"product_id",
productId.ToString()
}
};
if (after > 0)
{
parameters["after"] = after.ToString();
}
if (before > 0)
{
parameters["before"] = before.ToString();
}
VKRequestsDispatcher.DispatchRequestToVK <int>("store.reorderProducts", parameters, (Action <BackendResult <int, ResultCode> >)(result =>
{
bool resultData = result.ResultCode == ResultCode.Succeeded && result.ResultData == 1;
Action <BackendResult <bool, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <bool, ResultCode> backendResult = new BackendResult <bool, ResultCode>(result.ResultCode, resultData);
action(backendResult);
}), null, false, true, new CancellationToken?(), null);
}
public void GetData(GenericCollectionViewModel <GiftsResponse, GiftHeader> caller, int offset, int count, Action <BackendResult <GiftsResponse, ResultCode> > callback)
{
GiftsService.Instance.Get(this._userId, count, offset, (Action <BackendResult <GiftsResponse, ResultCode> >)(result =>
{
if (result.ResultCode == ResultCode.Succeeded)
{
bool giftsDenied = GiftsViewModel.IsAccessToGiftsDenied(result);
if (string.IsNullOrEmpty(this._firstNameGen))
{
User user = result.ResultData.user;
// ISSUE: explicit non-virtual call
this._firstNameGen = user != null ? user.first_name_gen : null;
// ISSUE: method pointer
Execute.ExecuteOnUIThread((Action)(() => this.NotifyPropertyChanged <string>((Expression <Func <string> >)(() => this.Title))));
}
this.AccessDeniedVisibility = giftsDenied.ToVisiblity();
// ISSUE: method pointer
Execute.ExecuteOnUIThread((Action)(() => this.NotifyPropertyChanged <Visibility>((Expression <Func <Visibility> >)(() => this.AccessDeniedVisibility))));
}
Action <BackendResult <GiftsResponse, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <GiftsResponse, ResultCode> backendResult = result;
action(backendResult);
}));
}
private async Task <bool> ProcessSingleDashboardRequest(FeedOperationDetails fod)
{
BackendResult <WallData, ResultCode> wall = await WallService.Current.GetWall(RemoteIdHelper.GetItemIdByRemoteId(fod.OwnerRemoteId), 0, 1, "owner");
if (wall.ResultCode == ResultCode.Succeeded && wall.ResultData.wall.Count > 0)
{
WallPost wallPost = wall.ResultData.wall[0];
FeedItem feedItem = this.CreateFeedItem(wallPost, wall.ResultData.groups, wall.ResultData.profiles, false);
if (feedItem != null)
{
DashboardItem dashboardItem = await SocialManager.OpenContactDashboardAsync(fod);
dashboardItem.DefaultTarget = feedItem.DefaultTarget;
dashboardItem.Timestamp = new DateTimeOffset(ExtensionsBase.UnixTimeStampToDateTime((double)wallPost.date, true));
if (!string.IsNullOrEmpty(feedItem.PrimaryContent.Title) || !string.IsNullOrEmpty(feedItem.PrimaryContent.Message))
{
dashboardItem.Content.Title = feedItem.PrimaryContent.Title;
dashboardItem.Content.Message = feedItem.PrimaryContent.Message;
}
else
{
dashboardItem.Content.Title = feedItem.SecondaryContent.Title;
dashboardItem.Content.Message = feedItem.SecondaryContent.Message;
}
dashboardItem.Content.Target = feedItem.PrimaryContent.Target;
await dashboardItem.SaveAsync();
return(true);
}
wallPost = null;
feedItem = null;
}
return(false);
}
public void GetData(string searchString, Dictionary <string, string> parameters, int offset, int count, Action <BackendResult <VKList <SearchHint>, ResultCode> > callback)
{
if (offset == 0 && string.IsNullOrWhiteSpace(searchString) && SearchHintsSearchDataProvider._preloadedSearchHintsLoaded)
{
Action <BackendResult <VKList <SearchHint>, ResultCode> > action = callback;
int num = 0;
VKList <SearchHint> resultData = new VKList <SearchHint>();
resultData.items = SearchHintsSearchDataProvider._preloadedSearchHints;
int count1 = SearchHintsSearchDataProvider._preloadedSearchHints.Count;
resultData.count = count1;
BackendResult <VKList <SearchHint>, ResultCode> backendResult = new BackendResult <VKList <SearchHint>, ResultCode>((ResultCode)num, resultData);
action(backendResult);
}
else
{
string query = searchString;
SearchService.Instance.GetSearchHints(searchString, (Action <BackendResult <List <SearchHint>, ResultCode> >)(result =>
{
if (result.ResultCode == ResultCode.Succeeded)
{
if (string.IsNullOrEmpty(query))
{
if (!SearchHintsSearchDataProvider._preloadedSearchHintsLoaded)
{
SearchHintsSearchDataProvider._preloadedSearchHints = new List <SearchHint>((IEnumerable <SearchHint>)result.ResultData);
SearchHintsSearchDataProvider._preloadedSearchHintsHeaders = new List <SearchHintHeader>((IEnumerable <SearchHintHeader>)Enumerable.Select <SearchHint, SearchHintHeader>(result.ResultData, (Func <SearchHint, SearchHintHeader>)(searchHint => new SearchHintHeader(searchHint))));
SearchHintsSearchDataProvider._preloadedSearchHintsLoaded = true;
}
}
else
{
string internalLink = SearchHintsSearchDataProvider.TryGetInternalLink(query);
if (!string.IsNullOrEmpty(internalLink))
{
result.ResultData.Add(new SearchHint()
{
type = "internal_link",
global = 1,
description = internalLink
});
}
result.ResultData.Add(new SearchHint()
{
type = "extended_search",
global = 1
});
}
callback(new BackendResult <VKList <SearchHint>, ResultCode>(result.ResultCode, new VKList <SearchHint>()
{
count = result.ResultData.Count,
items = result.ResultData
}));
}
else
{
callback(new BackendResult <VKList <SearchHint>, ResultCode>(result.ResultCode, null));
}
}));
}
}
public void GetBalanceData(Action <BackendResult <BalanceData, ResultCode> > callback)
{
VKRequestsDispatcher.DispatchRequestToVK <BalanceDataResponse>("execute.getBalanceData", new Dictionary <string, string>()
{
{
"type",
"votes"
},
{
"merchant",
"microsoft"
},
{
"no_inapp",
"1"
}
}, (Action <BackendResult <BalanceDataResponse, ResultCode> >)(result =>
{
BalanceData balanceData = new BalanceData();
ResultCode resultCode = result.ResultCode;
BalanceDataResponse resultData = result.ResultData;
List <StockItem> stockItems1 = null;
BackendResult <BalanceData, ResultCode> backendResult1 = new BackendResult <BalanceData, ResultCode>();
backendResult1.ResultCode = resultCode;
BalanceData balanceData1 = balanceData;
backendResult1.ResultData = balanceData1;
BackendResult <BalanceData, ResultCode> response = backendResult1;
if (resultData != null)
{
balanceData.Balance = resultData.balance;
VKList <StockItem> stockItems2 = resultData.stockItems;
stockItems1 = stockItems2 != null ? stockItems2.items : null;
}
if (result.ResultCode == ResultCode.Succeeded && stockItems1 != null)
{
VotesPacksGenerator.Generate(AppGlobalStateManager.Current.GlobalState.PaymentType, stockItems1, (Action <List <VotesPack> >)(votesPacks =>
{
balanceData.VotesPacks = votesPacks;
Action <BackendResult <BalanceData, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <BalanceData, ResultCode> backendResult2 = response;
action(backendResult2);
}));
}
else
{
Action <BackendResult <BalanceData, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <BalanceData, ResultCode> backendResult2 = response;
action(backendResult2);
}
}), null, false, true, new CancellationToken?(), null);
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req)
{
_logger.LogInformation($"C# HTTP trigger function AssignNewHostToCalendarItem processed a request.");
string tenant = req.Headers[Constants.HEADER_TENANT];
if (String.IsNullOrWhiteSpace(tenant))
{
tenant = null;
}
ServerSettings serverSettings = await _serverSettingsRepository.GetServerSettings(tenant);
string keyWord = req.Headers[Constants.HEADER_KEYWORD];
if (String.IsNullOrEmpty(keyWord) || !(serverSettings.IsUser(keyWord)))
{
return(new BadRequestErrorMessageResult("Keyword is missing or wrong."));
}
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
Participant participant = JsonConvert.DeserializeObject <Participant>(requestBody);
// Check if participant has an id
if (String.IsNullOrEmpty(participant.Id))
{
return(new OkObjectResult(new BackendResult(false, "Id des Teilnehmers fehlt.")));
}
if (String.IsNullOrEmpty(participant.ParticipantFirstName) || String.IsNullOrEmpty(participant.ParticipantLastName))
{
return(new OkObjectResult(new BackendResult(false, "Name unvollständig.")));
}
// Get and check corresponding CalendarItem
if (String.IsNullOrEmpty(participant.CalendarItemId))
{
return(new OkObjectResult(new BackendResult(false, "Terminangabe fehlt.")));
}
CalendarItem calendarItem = await _calendarRepository.GetItem(participant.CalendarItemId);
if (null == calendarItem)
{
return(new OkObjectResult(new BackendResult(false, "Angegebenen Termin nicht gefunden.")));
}
// Assign participant as new host
calendarItem.HostFirstName = participant.ParticipantFirstName;
calendarItem.HostLastName = participant.ParticipantLastName;
calendarItem.HostAdressInfo = participant.ParticipantAdressInfo;
calendarItem.WithoutHost = false;
// Set TTL and write CalendarItem to database
System.TimeSpan diffTime = calendarItem.StartDate.Subtract(DateTime.Now);
calendarItem.TimeToLive = serverSettings.AutoDeleteAfterDays * 24 * 3600 + (int)diffTime.TotalSeconds;
calendarItem = await _calendarRepository.UpsertItem(calendarItem);
// Delete host as participant
await _cosmosRepository.DeleteItemAsync(participant.Id);
BackendResult result = new BackendResult(true);
return(new OkObjectResult(result));
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req)
{
_logger.LogInformation($"C# HTTP trigger function AddCommentToCalendarItem processed a request.");
string tenant = req.Headers[Constants.HEADER_TENANT];
if (String.IsNullOrWhiteSpace(tenant))
{
tenant = null;
}
ServerSettings serverSettings = await _serverSettingsRepository.GetServerSettings(tenant);
string keyWord = req.Headers[Constants.HEADER_KEYWORD];
if (String.IsNullOrEmpty(keyWord) || !serverSettings.IsUser(keyWord))
{
return(new BadRequestErrorMessageResult("Keyword is missing or wrong."));
}
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
CalendarComment comment = JsonConvert.DeserializeObject <CalendarComment>(requestBody);
// Get and check corresponding CalendarItem
if (String.IsNullOrEmpty(comment.CalendarItemId))
{
return(new OkObjectResult(new BackendResult(false, "Terminangabe fehlt.")));
}
CalendarItem calendarItem = await _calendarRepository.GetItem(comment.CalendarItemId);
if (null == calendarItem)
{
return(new OkObjectResult(new BackendResult(false, "Angegebenen Termin nicht gefunden.")));
}
ExtendedCalendarItem extendedCalendarItem = new ExtendedCalendarItem(calendarItem);
// Read all participants for this calendar item
extendedCalendarItem.ParticipantsList = await _participantRepository.GetItems(p => p.CalendarItemId.Equals(extendedCalendarItem.Id));
// Set TTL for comment the same as for CalendarItem
System.TimeSpan diffTime = calendarItem.StartDate.Subtract(DateTime.Now);
comment.TimeToLive = serverSettings.AutoDeleteAfterDays * 24 * 3600 + (int)diffTime.TotalSeconds;
// Checkindate to track bookings
comment.CommentDate = DateTime.Now;
if (!String.IsNullOrWhiteSpace(tenant))
{
comment.Tenant = tenant;
}
comment = await _cosmosRepository.UpsertItem(comment);
if (!String.IsNullOrEmpty(comment.Comment))
{
await _subscriptionRepository.NotifyParticipants(extendedCalendarItem, comment.AuthorFirstName, comment.AuthorLastName, comment.Comment);
}
BackendResult result = new BackendResult(true);
return(new OkObjectResult(result));
}
public void GetStockItems(List <StoreProductFilter> productFilters = null, Action <BackendResult <List <StockItem>, ResultCode> > callback = null)
{
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{
"type",
"stickers"
},
{
"merchant",
"microsoft"
},
{
"no_inapp",
"1"
},
{
"extended",
"1"
}
};
if (productFilters != null && productFilters.Count > 0)
{
parameters["filters"] = string.Join(",", productFilters.Select <StoreProductFilter, string>((Func <StoreProductFilter, string>)(filter => filter.ToString().ToLowerInvariant())));
}
VKRequestsDispatcher.DispatchRequestToVK <ProductsWithStockItems>("execute.getProductsWithStockItems", parameters, (Action <BackendResult <ProductsWithStockItems, ResultCode> >)(result =>
{
List <StockItem> resultData1 = new List <StockItem>();
if (result.ResultCode == ResultCode.Succeeded)
{
ProductsWithStockItems resultData2 = result.ResultData;
if ((resultData2 != null ? resultData2.products.items : null) != null)
{
VKList <StockItem> stockItems = resultData2.stockItems;
if ((stockItems != null ? stockItems.items : null) != null)
{
foreach (StoreProduct storeProduct in resultData2.products.items)
{
StoreProduct product = storeProduct;
StockItem stockItem = resultData2.stockItems.items.FirstOrDefault <StockItem>((Func <StockItem, bool>)(i => i.product.id == product.id));
if (stockItem != null)
{
resultData1.Add(stockItem);
}
}
}
}
}
Action <BackendResult <List <StockItem>, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <List <StockItem>, ResultCode> backendResult = new BackendResult <List <StockItem>, ResultCode>(result.ResultCode, resultData1);
action(backendResult);
}), null, false, true, new CancellationToken?(), null);
}
internal void b__0(BackendResult <LookupContactsResponse, ResultCode> result)
{
ContactsSyncManager.c__DisplayClass9_0.d stateMachine;
stateMachine._4__this = this;
stateMachine.result = result;
stateMachine.t__builder = AsyncVoidMethodBuilder.Create();
stateMachine._1__state = -1;
stateMachine.t__builder.Start <ContactsSyncManager.c__DisplayClass9_0.d>(ref stateMachine);
}
public virtual BackendResult Build()
{
BackendResult result = null;
foreach (var package in Input.Packages)
{
result = Build(package);
}
return(result);
}
private static bool IsAccessToGiftsDenied(BackendResult <GiftsResponse, ResultCode> result)
{
List <ExecuteError> executeErrors = result.ExecuteErrors;
if (executeErrors != null)
{
return(Enumerable.Any <ExecuteError>(executeErrors, (Func <ExecuteError, bool>) new Func <ExecuteError, bool>(GiftsViewModel.IsAccessToGiftsDeniedError)));
}
return(false);
}
public async Task <BackendResult> AssignNewHostToCalendarItem(string tenant, string keyword, Participant participant)
{
BackendResult result = await $"https://{_functionsConfig.FunctionAppName}.azurewebsites.net/api/AssignNewHostToCalendarItem"
.WithHeader(HEADER_FUNCTIONS_KEY, _functionsConfig.ApiKey)
.WithHeader(HEADER_KEYWORD, keyword)
.WithHeader(HEADER_TENANT, tenant)
.PostJsonAsync(participant)
.ReceiveJson <BackendResult>();
return(result);
}
public async Task <BackendResult> DeleteInfoItem(string tenant, string keyword, InfoItem infoItem)
{
BackendResult result = await $"https://{_functionsConfig.FunctionAppName}.azurewebsites.net/api/DeleteInfoItem"
.WithHeader(HEADER_FUNCTIONS_KEY, _functionsConfig.ApiKey)
.WithHeader(HEADER_KEYWORD, keyword)
.WithHeader(HEADER_TENANT, tenant)
.PostJsonAsync(infoItem)
.ReceiveJson <BackendResult>();
return(result);
}
public async Task <BackendResult> RemoveCommentFromCalendarItem(string tenant, string keyword, CalendarComment comment)
{
BackendResult result = await $"https://{_functionsConfig.FunctionAppName}.azurewebsites.net/api/RemoveCommentFromCalendarItem"
.WithHeader(HEADER_FUNCTIONS_KEY, _functionsConfig.ApiKey)
.WithHeader(HEADER_KEYWORD, keyword)
.WithHeader(HEADER_TENANT, tenant)
.PostJsonAsync(comment)
.ReceiveJson <BackendResult>();
return(result);
}
public async void GetData(GenericCollectionViewModel <List <User>, Group <FriendHeader> > caller, int offset, int count, Action <BackendResult <List <User>, ResultCode> > callback)
{
if (this._pickUserMode == PickUserMode.PickForStickerPackGift)
{
StoreService.Instance.GetFriendsList(this._productId, (Action <BackendResult <List <User>, ResultCode> >)(result =>
{
if (result.ResultCode == ResultCode.Succeeded)
{
this._allFriendsRaw = result.ResultData;
}
Action <BackendResult <List <User>, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <List <User>, ResultCode> backendResult = result;
action(backendResult);
}));
}
else
{
SavedContacts friends = (SavedContacts)await FriendsCache.Instance.GetFriends();
if ((DateTime.UtcNow - friends.SyncedDate).TotalMinutes < 60.0)
{
List <User> resultData = null;
if (friends.SavedUsers != null)
{
resultData = this._sexFilter > 0 ? (List <User>)Enumerable.ToList <User>(Enumerable.Where <User>(friends.SavedUsers, (Func <User, bool>)(u => u.sex == this._sexFilter))) : friends.SavedUsers;
}
this._allFriendsRaw = resultData;
callback(new BackendResult <List <User>, ResultCode>(ResultCode.Succeeded, resultData));
}
else
{
UsersService.Instance.GetFriendsForCurrentUser((Action <BackendResult <List <User>, ResultCode> >)(res =>
{
if (res.ResultCode == ResultCode.Succeeded)
{
List <User> userList = null;
if (res.ResultData != null)
{
userList = this._sexFilter > 0 ? (List <User>)Enumerable.ToList <User>(Enumerable.Where <User>(res.ResultData, (Func <User, bool>)(u => u.sex == this._sexFilter))) : res.ResultData;
}
this._allFriendsRaw = userList;
}
callback(res);
}));
}
}
}
public async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req)
{
_logger.LogInformation($"C# HTTP trigger function AddCommentToInfoItem processed a request.");
string tenant = req.Headers[Constants.HEADER_TENANT];
if (String.IsNullOrWhiteSpace(tenant))
{
tenant = null;
}
ServerSettings serverSettings = await _serverSettingsRepository.GetServerSettings(tenant);
string keyWord = req.Headers[Constants.HEADER_KEYWORD];
if (String.IsNullOrEmpty(keyWord) || !serverSettings.IsUser(keyWord))
{
return(new BadRequestErrorMessageResult("Keyword is missing or wrong."));
}
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
CalendarComment comment = JsonConvert.DeserializeObject <CalendarComment>(requestBody);
// Get and check corresponding CalendarItem
if (String.IsNullOrEmpty(comment.CalendarItemId))
{
return(new OkObjectResult(new BackendResult(false, "Terminangabe fehlt.")));
}
InfoItem infoItem = await _infoRepository.GetItem(comment.CalendarItemId);
if (null == infoItem)
{
return(new OkObjectResult(new BackendResult(false, "Angegebenen Termin nicht gefunden.")));
}
if (!infoItem.CommentsAllowed)
{
return(new OkObjectResult(new BackendResult(false, "Keine Kommentare hier erlaubt.")));
}
if (infoItem.CommentsLifeTimeInDays > 0)
{
comment.TimeToLive = infoItem.CommentsLifeTimeInDays * 24 * 3600;
}
comment.CommentDate = DateTime.Now;
if (!String.IsNullOrWhiteSpace(tenant))
{
comment.Tenant = tenant;
}
comment = await _cosmosRepository.UpsertItem(comment);
BackendResult result = new BackendResult(true);
return(new OkObjectResult(result));
}
private static void SaveProfilePhoto(UploadPhotoResponseData responseData, long ownerId, Action <BackendResult <ProfilePhoto, ResultCode> > callback)
{
Action <BackendResult <ProfilePhoto, ResultCode> > callback1 = (Action <BackendResult <ProfilePhoto, ResultCode> >)(result =>
{
if (result.ResultCode == ResultCode.Succeeded && ownerId < 0L)
{
BackendResult <ProfilePhoto, ResultCode> savePhotoResult = result;
Action <BackendResult <Group[], ResultCode> > callback2 = (Action <BackendResult <Group[], ResultCode> >)(getGroupResult =>
{
if (getGroupResult.ResultCode == ResultCode.Succeeded)
{
savePhotoResult.ResultData.photo_200 = ((IEnumerable <Group>)getGroupResult.ResultData).First <Group>().photo_200;
callback(savePhotoResult);
}
else
{
result.ResultCode = getGroupResult.ResultCode;
callback(result);
}
});
VKRequestsDispatcher.DispatchRequestToVK <Group[]>("groups.getById", new Dictionary <string, string>()
{
{
"group_id",
(-ownerId).ToString()
}
}, callback2, (Func <string, Group[]>)null, false, true, new CancellationToken?(), null);
}
else
{
callback(result);
}
});
VKRequestsDispatcher.DispatchRequestToVK <ProfilePhoto>("photos.saveOwnerPhoto", new Dictionary <string, string>()
{
{
"server",
responseData.server
},
{
"photo",
responseData.photo
},
{
"hash",
responseData.hash
}
}, callback1, null, false, true, new CancellationToken?(), null);
}
private void Initialize()
{
EventAggregator.Current.Subscribe((object)this);
this._helperGetFriendsAndMutual = new AsyncHelper <BackendResult <FriendsAndMutualFriends, ResultCode> >((Action <Action <BackendResult <FriendsAndMutualFriends, ResultCode> > >)(a => UsersService.Instance.GetFriendsAndMutual(this._uid, a)));
this._helperGetCurrentUserFriends = new AsyncHelper <BackendResult <List <User>, ResultCode> >((Action <Action <BackendResult <List <User>, ResultCode> > >)(a => UsersService.Instance.GetFriendsWithRequests((Action <BackendResult <AllFriendsList, ResultCode> >)(async(res) =>
{//omg_re async
if (res.ResultCode == ResultCode.Succeeded)
{
FriendsCache.Instance.SetFriends(res.ResultData.friends, res.ResultData.requests);
await ContactsManager.Instance.SyncContactsAsync(res.ResultData.friends);
this.RequestsViewModel = res.ResultData.requests;
CountersManager.Current.Counters.friends = this.RequestsViewModel.menu_counter;
EventAggregator.Current.Publish((object)new CountersChanged(CountersManager.Current.Counters));
}
Action <BackendResult <List <User>, ResultCode> > action = a;
BackendResult <List <User>, ResultCode> backendResult = new BackendResult <List <User>, ResultCode>();
backendResult.Error = res.Error;
backendResult.ResultCode = res.ResultCode;
AllFriendsList resultData = res.ResultData;
List <User> userList = resultData != null ? resultData.friends : (List <User>)null;
backendResult.ResultData = userList;
action(backendResult);
}))));
this._helperFriendsFromList = new AsyncHelper <BackendResult <List <User>, ResultCode> >((Action <Action <BackendResult <List <User>, ResultCode> > >)(a => UsersService.Instance.GetFriendsForList(this._lid, a)));
this._allFriendsVM = new GenericCollectionViewModel <List <User>, Group <FriendHeader> >((ICollectionDataProvider <List <User>, Group <FriendHeader> >) this)
{
NeedCollectionCountBeforeFullyLoading = true,
RecreateCollectionOnRefresh = true
};
this._onlineFriendsVM = new GenericCollectionViewModel <List <User>, FriendHeader>((ICollectionDataProvider <List <User>, FriendHeader>) this)
{
NeedCollectionCountBeforeFullyLoading = true
};
this._commonFriendsVM = new GenericCollectionViewModel <List <User>, FriendHeader>((ICollectionDataProvider <List <User>, FriendHeader>) this)
{
NeedCollectionCountBeforeFullyLoading = true
};
this._friendsListVM = new GenericCollectionViewModel <List <FriendsList>, FriendHeader>((ICollectionDataProvider <List <FriendsList>, FriendHeader>) this)
{
NeedCollectionCountBeforeFullyLoading = true
};
if (this._lid != 0)
{
return;
}
this._allFriendsVM.NoContentText = CommonResources.NoContent_Friends;
this._allFriendsVM.NoContentImage = "../Resources/NoContentImages/Friends.png";
}
public void GetData(string searchString, Dictionary <string, string> parameters, int offset, int count, Action <BackendResult <VKList <Group>, ResultCode> > callback)
{
if (this._isManagedOnly)
{
BackendResult <VKList <Group>, ResultCode> backendResult = new BackendResult <VKList <Group>, ResultCode>()
{
ResultCode = ResultCode.Succeeded,
ResultData = new VKList <Group>()
};
callback(backendResult);
}
else
{
GroupsService.Current.Search(searchString, offset, count, callback);
}
}
internal BuildResult(Log log, Project project, BuildTarget target, ICompiler compiler, BuildOptions options, BuildFile file, BackendResult result)
{
Log = log;
Project = project;
Target = target;
File = file;
Compiler = compiler;
ErrorCount = log.ErrorCount;
WarningCount = log.WarningCount;
OutputDirectory = compiler.Environment.OutputDirectory;
RunArguments = options.RunArguments;
BackendResult = result;
IL = compiler.Data.IL;
Entrypoint = compiler.Data.Entrypoint;
IsDebug = compiler.Environment.Debug;
}
private async Task <bool> ProcessContactFeeds(List <FeedOperationDetails> fodList)
{
List <WallService.WallRequestData> requestData = new List <WallService.WallRequestData>();
using (List <FeedOperationDetails> .Enumerator enumerator = fodList.GetEnumerator())
{
while (enumerator.MoveNext())
{
FeedOperationDetails current = enumerator.Current;
requestData.Add(new WallService.WallRequestData()
{
UserId = RemoteIdHelper.GetItemIdByRemoteId(current.OwnerRemoteId),
Offset = this.GetRequiredOffset(current),
Count = current.ItemCount
});
}
}
BackendResult <List <WallData>, ResultCode> res = await WallService.Current.GetWallForManyUsers(requestData);
if (res.ResultCode != ResultCode.Succeeded)
{
return(false);
}
for (int i = 0; i < fodList.Count && i < res.ResultData.Count; ++i)
{
FeedOperationDetails fod = fodList[i];
WallData currentWallData = res.ResultData[i];
int nextOffset = this.GetRequiredOffset(fod) + currentWallData.wall.Count;
Feed feed = await SocialManager.OpenContactFeedAsync(fod);
foreach (WallPost wallPost in currentWallData.wall)
{
FeedItem feedItem = this.CreateFeedItem(wallPost, currentWallData.groups, currentWallData.profiles, true);
if (feedItem != null)
{
this.SetRequiredOffset(feedItem, nextOffset);
((ICollection <FeedItem>)feed.Items).Add(feedItem);
}
}
await feed.SaveAsync();
currentWallData = null;
}
return(true);
}
private static void HandleStorePurchaseError(BackendResult <StorePurchaseResult, ResultCode> result, Action callback = null)
{
ResultCode resultCode = result.ResultCode;
if (resultCode != ResultCode.Succeeded)
{
GenericInfoUC.ShowBasedOnResult(resultCode, "", (VKRequestsDispatcher.Error)null);
}
else if (result.ResultData != null && result.ResultData.state < 0)
{
Execute.ExecuteOnUIThread((Action)(() => new GenericInfoUC(2000).ShowAndHideLater(result.ResultData.error_message ?? CommonResources.UnableToCompletePurchase, null)));
}
if (callback == null)
{
return;
}
callback();
}
private void HandleLogin(BackendResult <AutorizationData, ResultCode> result)
{
ServiceLocator.Resolve <IAppStateInfo>().HandleSuccessfulLogin(result.ResultData, false);
if (string.IsNullOrEmpty(this._registrationProfileVM.FullAvatarUri))
{
return;
}
SettingsEditProfileViewModel profileViewModel = new SettingsEditProfileViewModel();
using (IsolatedStorageFile storeForApplication = IsolatedStorageFile.GetUserStoreForApplication())
{
MemoryStream memoryStream = new MemoryStream();
using (IsolatedStorageFileStream storageFileStream = storeForApplication.OpenFile(this._registrationProfileVM.FullAvatarUri, FileMode.Open, FileAccess.Read))
memoryStream = StreamUtils.ReadFully((Stream)storageFileStream);
memoryStream.Position = 0L;
profileViewModel.UploadUserPhoto((Stream)memoryStream, this._registrationProfileVM.CropPhotoRect);
}
}
private async Task <bool> ProcessConnectData(DownloadRichConnectDataOperation downloadRichConnectDataOperation)
{
ContactBindingManager store = await ContactBindings.GetAppContactBindingManagerAsync();
ContactStore contactStore = await ContactStore.CreateOrOpenAsync();
foreach (string id in (IEnumerable <string>)downloadRichConnectDataOperation.Ids)
{
string remoteId = id;
try
{
string title = (await contactStore.FindContactByRemoteIdAsync(remoteId)).DisplayName;
ContactBinding contactBinding = await store.GetContactBindingByRemoteIdAsync(remoteId);
ConnectTileData connectTileData = new ConnectTileData();
connectTileData.Title = title;
BackendResult <PhotosListWithCount, ResultCode> profilePhotos = await PhotosService.Current.GetProfilePhotos(RemoteIdHelper.GetItemIdByRemoteId(remoteId), 0, 3);
if (profilePhotos.ResultCode == ResultCode.Succeeded)
{
for (int index = 0; index < Math.Min(3, profilePhotos.ResultData.response.Count); ++index)
{
Photo photo = profilePhotos.ResultData.response[index];
ConnectTileImage connectTileImage = new ConnectTileImage();
connectTileImage.ImageUrl = photo.src_big;
((ICollection <ConnectTileImage>)connectTileData.Images).Add(connectTileImage);
}
}
contactBinding.TileData = connectTileData;
await store.SaveContactBindingAsync(contactBinding);
title = null;
contactBinding = null;
connectTileData = null;
}
catch (Exception ex)
{
Logger.Instance.Error("ProcessConnectData failed", ex);
}
remoteId = null;
}
return(true);
}
public static void ShowAndReloadStickers(long stickerId, string referrer)
{
StickersPackView.ShowWithLoader(referrer, (Action <Action <BackendResult <StockItem, ResultCode> >, CancellationToken>)((callback, cancellationToken) => StoreService.Instance.GetStockItemByStickerId(stickerId, (Action <BackendResult <StockItem, ResultCode> >)(result =>
{
if (result.ResultCode == ResultCode.Succeeded)
{
StockItem resultData = result.ResultData;
StoreProduct storeProduct = resultData != null ? resultData.product : null;
if (storeProduct != null && storeProduct.purchased == 1 && storeProduct.active == 1)
{
EventAggregator.Current.Publish(new StickersUpdatedEvent(new StockItemHeader(resultData, false, 0, false)));
}
}
Action <BackendResult <StockItem, ResultCode> > action = callback;
if (action == null)
{
return;
}
BackendResult <StockItem, ResultCode> backendResult = result;
action(backendResult);
}), new CancellationToken?(cancellationToken))), 0, false);
}
private async Task <bool> ProcessHomeFeed(DownloadHomeFeedOperation downloadHomeFeedOperation)
{
try
{
List <Task> taskList = new List <Task>();
FeedOperationDetails op = downloadHomeFeedOperation.FeedOperationDetails;
BackendResult <NewsFeedData, ResultCode> res = await NewsFeedService.Current.GetNewsFeed(this.CreateNewsFeedGetParams(op));
if (res.ResultCode == ResultCode.Succeeded)
{
NewsFeedData newsFeedData = res.ResultData;
Feed feed = await SocialManager.OpenHomeFeedAsync(op);
foreach (NewsItem newsFeedItem in newsFeedData.items)
{
FeedItem feedItem = this.CreateFeedItem(newsFeedItem, newsFeedData.groups, newsFeedData.profiles);
if (feedItem != null)
{
((ICollection <FeedItem>)feed.Items).Add(feedItem);
}
}
if (((IEnumerable <FeedItem>)feed.Items).Any <FeedItem>())
{
RemoteIdHelper.NewsFeedNewFromData.Instance.SetParams(((IEnumerable <FeedItem>)feed.Items).Last <FeedItem>().RemoteId, res.ResultData.new_offset, res.ResultData.next_from);
}
await feed.SaveAsync();
newsFeedData = (NewsFeedData)null;
}
return(res.ResultCode == ResultCode.Succeeded);
}
catch
{
Debugger.Break();
return(false);
}
}
public void GetUpdates(string serverName, string key, long ts, Action <BackendResult <UpdatesResponse, LongPollResultCode> > callback)
{
JsonWebRequest.SendHTTPRequestAsync(string.Format(this._getUpdatesURIFrm, serverName, key, ts), (Action <JsonResponseData>)(jsonResp =>
{
BackendResult <UpdatesResponse, LongPollResultCode> backendResult = new BackendResult <UpdatesResponse, LongPollResultCode>();
if (!jsonResp.IsSucceeded || string.IsNullOrWhiteSpace(jsonResp.JsonString))
{
backendResult.ResultCode = LongPollResultCode.CommunicationFailed;
}
else if (this.ServerReturnedFailure(jsonResp.JsonString))
{
backendResult.ResultCode = LongPollResultCode.RequireNewPollServer;
}
else
{
backendResult.ResultCode = LongPollResultCode.Succeeded;
LongPollServerService.RootObjectGetUpdates objectGetUpdates = JsonConvert.DeserializeObject <LongPollServerService.RootObjectGetUpdates>(jsonResp.JsonString);
backendResult.ResultData = new UpdatesResponse();
backendResult.ResultData.ts = (long)objectGetUpdates.ts;
backendResult.ResultData.Updates = this.ReadUpdatesResponseFromRaw(objectGetUpdates.updates, new Func <List <object>, LongPollServerUpdateData>(this.GetUpdateDataForNewMessageLongPollData));
}
callback(backendResult);
}), null);
}
