async public Task <ResolverResponse> Resolve(object server, object local)
        {
            const string keepLocal  = "Keep your changes";
            const string keepServer = "Keep their changes";
            const string cancel     = "Cancel";
            string       answer     = null;

            ResolverResponse result = new ResolverResponse();

            answer = await DisplayActionSheet("Someone else has updated this same record so you will have to decide which changes you want to keep.\n\nYour Changes:\n" + local + "\n\nTheir Changes:\n" + server, cancel, null, keepLocal, keepServer);

            if (answer == keepLocal)
            {
                result = ResolverResponse.LocalVersion;
            }
            else if (answer == keepServer)
            {
                result = ResolverResponse.ServerVersion;
            }
            else
            {
                result = ResolverResponse.Cancel;
            }

            return(result);
        }
        public ResolverResponse Post([FromBody] int[,] value)
        {
            var logs     = new List <string>();
            var resolver = new SudokuResolver(value, m => logs.Add(m));
            var result   = resolver.Resolve();

            var response = new ResolverResponse
            {
                Matrix     = value,
                Logs       = logs,
                Resolved   = result,
                RangeItems = resolver.RangeItems
            };

            return(response);
        }
        /// <summary>
        /// Sync conflict resolution logic
        /// </summary>
        /// <param name="operation"></param>
        /// <returns></returns>
        /// <remarks>
        /// Gets called by SDK when it detects a synchronization conflict during sync operations.
        /// If there are multiple conflicts during a sync operation then this method will be called
        /// once for each conflict.
        /// </remarks>
        public virtual async Task <JObject> ExecuteTableOperationAsync(IMobileServiceTableOperation operation)
        {
            MobileServicePreconditionFailedException error;

            do
            {
                error = null;

                try
                {
                    return(await operation.ExecuteAsync());
                }
                catch (MobileServicePreconditionFailedException ex)
                {
                    error = ex;
                }

                if (error != null)
                {
                    var serverValue = error.Value;

                    ResolverResponse resolution = await ConflictResolver(serverValue, operation.Item);

                    if (resolution == ResolverResponse.LocalVersion)
                    {
                        // Overwrite the server version and try the operation again by continuing the loop
                        operation.Item[MobileServiceSystemColumns.Version] = serverValue[MobileServiceSystemColumns.Version];
                        continue;
                    }
                    else if (resolution == ResolverResponse.ServerVersion)
                    {
                        return((JObject)serverValue);
                    }
                    else
                    {
                        operation.AbortPush();
                    }
                }
            } while (error != null);

            return(null);
        }