public User(StateManager stateMgr, API.Geo.World world)
        {
            this.mStateMgr = stateMgr;
            this.mWorld = world;
            this.mTimeSinceGUIOpen = new Timer();

            this.mCameraMan = null;
            this.IsAllowedToMoveCam = true;
            this.IsFreeCamMode = true;
            Camera cam = this.mStateMgr.Camera;
            cam.Position = new Vector3(-203, 633, -183);
            cam.Orientation = new Quaternion(0.3977548f, -0.1096644f, -0.8781486f, -0.2421133f);
            this.mCameraMan = new CameraMan(cam);
            this.mSelectedAllies = new HashSet<VanillaNonPlayer>();
            this.mRandom = new Random();

            this.mFigures = new MOIS.KeyCode[10];
            for (int i = 0; i < 9; i++)
                this.mFigures[i] = (MOIS.KeyCode)System.Enum.Parse(typeof(MOIS.KeyCode), "KC_" + (i + 1));
            this.mFigures[9] = MOIS.KeyCode.KC_0;

            this.mWireCube = this.mStateMgr.SceneMgr.RootSceneNode.CreateChildSceneNode();
            this.mWireCube.AttachObject(StaticRectangle.CreateRectangle(this.mStateMgr.SceneMgr, Vector3.UNIT_SCALE * Cst.CUBE_SIDE));
            this.mWireCube.SetVisible(false);

            this.Inventory = new Inventory(10, 4, new int[] { 3, 0, 1, 2 }, true);
        }

 public GitHubRequest(string resource,
                      API version,
                      Method method,
                      params Parameter[] parameters)
     : this(resource, version, method, /*body:*/null, parameters)
 {
 }

		internal void Update(API.Invite model)
		{
			if (model.Channel != null)
				ChannelId = model.Channel.Id;
			if (model.Inviter != null)
				InviterId = model.Inviter.Id;
		}

 private void RunProcessor(API.Request request, Processor processor, string processorName)
 {
     API.Response response = null;
     try
     {
         // Threadpooling
         response = processor.process(request);
     }
     catch (Exception e)
     {
         Logger.Error("Failed to process message with processor " + processor.GetType() + " : " + e.Message, e);
         try
         {
             Type responseType = Type.GetType("Gwupe.Cloud.Messaging.Response." + processorName + "Rs");
             response = (API.Response) responseType.GetConstructor(Type.EmptyTypes).Invoke(new object[] {});
             response.error = "UNKNOWN_ERROR";
             response.errorMessage = e.Message;
         }
         catch (Exception exception)
         {
             Logger.Error("Failed to determine return type for " + processorName);
             response = new ErrorRs
                 {
                     errorMessage = "Failed to determine return type for " + processorName,
                     error = "INTERNAL_SERVER_ERROR"
                 };
         }
     }
     finally
     {
         SendResponse(response, request);
     }
 }

 public A2iAOcrProcessingService(API a2iaEngine, string parameterPath, string tableFilename, LoadMethod loadMethod)
 {
     _a2iaEngine = a2iaEngine;
     _parameterDirectory = parameterPath;
     _documentTableFilename = tableFilename;
     _loadMethod = loadMethod;
 }

        private void balanceButton_Click(object sender, EventArgs e)
        {
            try
            {
                API api = new API(key.Text);

                Clockwork.Balance result = api.GetBalance();

                balance.Text = result.CurrencySymbol + result.Amount.ToString("#,0.00");
            }
            catch (APIException ex)
            {
                // You'll get an API exception for errors
                // such as wrong key
                MessageBox.Show("API Exception: " + ex.Message);
            }
            catch (WebException ex)
            {
                // Web exceptions mean you couldn't reach the mediaburst server
                MessageBox.Show("Web Exception: " + ex.Message);
            }
            catch (ArgumentException ex)
            {
                // Argument exceptions are thrown for missing parameters,
                // such as forgetting to set the username
                MessageBox.Show("Argument Exception: " + ex.Message);
            }
            catch (Exception ex)
            {
                // Something else went wrong, the error message should help
                MessageBox.Show("Unknown Exception: " + ex.Message);
            }
        }

        public void Execute(API.CommandManager manager, IRemoteCommandArguments arguments)
        {
            var args = (ExpectValueArguments)arguments;

            Guard.ArgumentNotNullForCommand<ExpectValue>(args.Value, args.ValueExpression);
            Guard.ArgumentNotNullForCommand<ExpectValue>(args.Selector);

            API.ExpectCommands.Value valueExpect = null;
            if (args.Value != null)
            {
                valueExpect = manager.Expect.Value(args.Value);
            }
            else
            {
                valueExpect = manager.Expect.Value(args.ValueExpression);
            }

            if (args.MatchConditions.HasValue)
            {
                valueExpect.In(args.Selector, args.MatchConditions.Value);
            }
            else
            {
                valueExpect.In(args.Selector);
            }
        }

        public static Func<List<ImportedKit>> ListImportedKits(API.V1 api)
        {
            return delegate() {
                string root = FileUtils.Root + FileUtils.NormalizePathForPlatform ("/Fabric/Kits/");

                List<ImportedKit> kits = new List<ImportedKit> ();

                if (!Directory.Exists (root)) {
                    return kits;
                }

                foreach (string kit in Directory.GetDirectories (root)) {
                    string unqualified = kit.Substring (kit.LastIndexOf (Path.DirectorySeparatorChar) + 1);
                    string qualified = String.Format ("Fabric.Internal.{0}.Editor.Controller.Controller", unqualified);

                    Type type = Type.GetType (qualified);

                    // Those kits without a controller will not be displayed in the KitSelector
                    // as they do not have a GUI component to them.
                    if (type == null) {
                        continue;
                    }
                    object instance = Activator.CreateInstance (type, api);

                    kits.Add (new ImportedKit (unqualified, instance));
                }

                return kits;
            };
        }

 public static void SaveSettings(API.Settings.Settings s)
 {
     using (var sr = new StreamWriter("settings.config"))
     {
         sr.Write(Utilities.Serialize(s));
     }
 }

        private async void Autenticar()
        {
            API api = new API();

            string resposta;


            //    ObservableCollection<Users> x =await api.GetAllUser();


            resposta = api.GetAsync(User, Senha);
            if (resposta == "Logado")
            {
                await _dialogservice.DisplayAlertAsync("Sucess", "Loading...", "ok,");

                await _navigationService.NavigateAsync("InicialPage");
            }

            else
            {
                await _dialogservice.DisplayAlertAsync("Erro", "Senha e/ou Usuario incorreto", "ok,");

            }

        

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="container"></param>
        public FacebookService(IContainer container)
        {
            if (container != null) container.Add(this);

            api = new API();
            InitializeComponent();
        }

        public void PostData(StringContent content, API api)
        {
            var client = PrepareHttpClient();
            using (client)
            {
                string apiStr = Enum.GetName(typeof(API), api);
                
                var request = client.PostAsync("api/"+apiStr, content).Result;
                var result = request.Content.ReadAsStringAsync().Result;
                
                // result = "{\"StatusCode\":201,\"StatusDescription\":\"New call was created with id : 5631004a4ca8e9290cddd46b\"}" on success

                Dictionary<string, string> jsonDictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(result);

                var statusCode = jsonDictionary["StatusCode"];
                var statusDesc = jsonDictionary["StatusDescription"];

                var seperator = statusDesc.IndexOf(":");

                var callId = statusDesc.Substring(seperator+1).Trim();

                MongoCallId = callId;

                // If result is not as below, throw exception
                if (!statusCode.Contains("201"))
                {
                    throw new Exception("Error sending call: Response result code not 201!");
                }

            }
        }

 protected void SendJson(API.ReturnObject o)
 {
     Response.ContentType = "application/json";
     Response.StatusCode = 200;
     Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(o));
     Response.End();
 }

        public EditAPI(Project project, API api)
        {
            InitializeComponent();

            _project = project;
            _api = api;
        }

 public TestParameters_WaitAllAny(API api, int waitTime, WaitBy waitBy, TaskInfo[] allTasks)
 {
     Api = api;
     WaitBy = waitBy;
     WaitTime = waitTime;
     AllTaskInfos = allTasks;
 }

		internal void Update(API.RoleInfo model)
		{
			Name = model.Name;
			Permissions.RawValue = (uint)model.Permissions;

			foreach (var member in Members)
				member.UpdatePermissions();
		}

 public A2iABatchPoolService(API a2IaEngine, IA2iaConfiguration configuration) :
     base(a2IaEngine, configuration)
 {
     const int capacity = 100;
     batchRegistration = new ConcurrentDictionary<string, int>(GetMaxThreadCount(3), capacity);
     VoucherQueue = new ConcurrentQueue<OcrVoucher>();
     VoucherProcessingBag = new ConcurrentBag<OcrVoucher>();
 }

        public void Execute(API.CommandManager manager, IRemoteCommandArguments arguments)
        {
            var args = (TypeArguments)arguments;

            Guard.ArgumentNotNullForCommand<Type>(args.Value);

            manager.Type(args.Value);
        }

 public void display(Island currentIsland, API.Geo.World currentWorld)
 {
     if (this.faceNumber > 0) {
         block.End();
         this.node = this.mIsland.Node.CreateChildSceneNode("MultiBlockNode-" + this.mName);
         this.node.AttachObject(block);
     }
 }

 protected override string Generate_ProjectFile(API.IZetboxContext ctx, string projectGuid, List<string> generatedFileNames, IEnumerable<ISchemaProvider> schemaProviders)
 {
     return RunTemplate(ctx, "ProjectFile",
                  TargetNameSpace + ".csproj",
                  projectGuid,
                  generatedFileNames.Where(s => !String.IsNullOrEmpty(s)).ToList(),
                  schemaProviders);
 }