Beispiel #1
0
        /// <summary>
        /// Wrong name. Does in fact check if the user may be added, then ALSO adds the user to the node
        /// </summary>
        /// <param name="user"></param>
        /// <param name="ship"></param>
        /// <param name="node"></param>
        /// <returns></returns>
        public static string checkShipAtCommNode(Core.User user, Core.Ship ship, Core.CommunicationNode node)
        {
            string ret = "";


            //List<SpacegameServer.Core.DiplomaticRelation> newContacts = new List<SpacegameServer.Core.DiplomaticRelation>();
            if (!node.checkAndAddUser(user, ship))
            {
                return(ret);
            }

            SpacegameServer.BC.XMLGroups.CommNodeData nodeData = new SpacegameServer.BC.XMLGroups.CommNodeData();
            //nodeData.xmlKnownUsers = SpacegameServer.BC.XMLGroups.UserContacts.createContacts(user, newContacts);


            nodeData.commNodes          = new XMLGroups.CommNodes();
            nodeData.commNodes.commNode = new List <XMLGroups.CommNode>();
            nodeData.commNodes.commNode.Add(XMLGroups.CommNode.createCommNode(node, user));

            //Todo: only transfer "new" alliance contact data
            //nodeData.allianceDiplomacy = XMLGroups.KnownAlliances.createAllianceContacts(user);
            //nodeData.allianceRelations = XMLGroups.AllianceUserRelations.createAllianceUserRelations(user);

            BusinessConnector.Serialize <SpacegameServer.BC.XMLGroups.CommNodeData>(nodeData, ref ret, true);

            return(ret);
        }
        public string getReceivedMessages(
            int userId,
            int fromNr,        // fromNr  the earliest already received message
            int toNr,          // toNr 50 means 50 messages more to read (towards the past)  -> from . to counts backwards (current messages are already loaded, so fetch older ones with this call)
            int lastMessageId, // The highest ID that the user already got (if he is currently fetching oler messages, unreceived newer ones should also be transferred
            int messageType)   // Filter for message type
        {
            string xml = "";

            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return(xml);
            }
            Core.User user = Core.Core.Instance.users[userId];

            try
            {
                xml = (new BC.Message(user)).getReceivedMessages(userId, fromNr, toNr, lastMessageId, messageType);
            }
            catch (Exception ex)
            {
                SpacegameServer.Core.Core.Instance.writeExceptionToLog(ex);
            }

            return(xml);
        }
        public string getCommNodeMessage(int userId, int commNodeId, int from, int to)
        {
            string xml = "";

            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return(xml);
            }
            if (!Core.Core.Instance.commNodes.ContainsKey(commNodeId))
            {
                return(xml);
            }

            Core.User user = Core.Core.Instance.users[userId];
            Core.CommunicationNode node = Core.Core.Instance.commNodes[commNodeId];

            try
            {
                xml = (new BC.CommNode(node, user)).getCommNodeMessages(from, to);
            }
            catch (Exception ex)
            {
                SpacegameServer.Core.Core.Instance.writeExceptionToLog(ex);
            }

            return(xml);
        }
        public string leaveAlliance(int userId, int userToRemoveId, int allianceId)
        {
            string xml = "";

            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return(xml);
            }
            Core.User user = Core.Core.Instance.users[userId];

            if (!Core.Core.Instance.users.ContainsKey(userToRemoveId))
            {
                return(xml);
            }
            Core.User userToRemove = Core.Core.Instance.users[userToRemoveId];

            try
            {
                xml = BC.Alliance.leaveAlliance(user, userToRemove, allianceId);
            }
            catch (Exception ex)
            {
                SpacegameServer.Core.Core.Instance.writeExceptionToLog(ex);
            }

            return(xml);
        }
        public string getMessagesText(int userId, int messageId)
        {
            string xml = "";

            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return(xml);
            }
            if (!Core.Core.Instance.messages.ContainsKey(messageId))
            {
                return(xml);
            }
            Core.User user = Core.Core.Instance.users[userId];

            try
            {
                xml = (new BC.Message(user)).getMessagesText(userId, messageId);
            }
            catch (Exception ex)
            {
                SpacegameServer.Core.Core.Instance.writeExceptionToLog(ex);
            }

            return(xml);
        }
        /// <summary>
        /// creates all contact Informations
        /// </summary>
        /// <param name="player"></param>
        /// <returns></returns>
        public static UserContacts createAllContacts(Core.User player)
        {
            UserContacts knownUsers = new UserContacts();

            knownUsers.knownUser = new List <UserContact>();

            foreach (var targetRelation in Core.Core.Instance.userRelations.getAllDiplomatics(player, 1))
            {
                Core.User targetUser = (Core.User)targetRelation.target;

                knownUsers.knownUser.Add(
                    new UserContact(targetUser.id, targetUser.username,
                                    targetRelation.relation, targetRelation.relationSenderProposal, targetRelation.relationTargetProposal,
                                    //Math.Min(relations.Key, relations.Value), relations.Key, relations.Value,
                                    targetUser.popVicPoints,
                                    targetUser.researchVicPoints,
                                    targetUser.goodsVicPoints,
                                    targetUser.shipVicPoints,
                                    targetUser.overallVicPoints,
                                    targetUser.overallRank,
                                    targetUser.allianceId,
                                    targetUser.AiId,
                                    targetUser.AiRelation,
                                    targetUser.ProfileUrl)
                    );
            }
            return(knownUsers);
        }
        /// <summary>
        /// creates a single contact information
        /// </summary>
        /// <param name="player">player</param>
        /// <param name="target">targetUser</param>
        /// <returns></returns>
        public static UserContacts createContact(Core.User player, Core.User targetUser)
        {
            UserContacts knownUsers = new UserContacts();

            knownUsers.knownUser = new List <UserContact>();

            SpacegameServer.Core.FullDiplomaticRelationProposals targetRelation = Core.Core.Instance.userRelations.getDiplomaticsToUser(player, targetUser);

            knownUsers.knownUser.Add(
                new UserContact(targetUser.id, targetUser.username,
                                targetRelation.relation, targetRelation.relationSenderProposal, targetRelation.relationTargetProposal,
                                //Math.Min(relations.Key, relations.Value), relations.Key, relations.Value,
                                targetUser.popVicPoints,
                                targetUser.researchVicPoints,
                                targetUser.goodsVicPoints,
                                targetUser.shipVicPoints,
                                targetUser.overallVicPoints,
                                targetUser.overallRank,
                                targetUser.allianceId,
                                targetUser.AiId,
                                targetUser.AiRelation,
                                targetUser.ProfileUrl)
                );

            return(knownUsers);
        }
        public static AllianceInvites createAllianceInvites(Core.User player)
        {
            AllianceInvites invites = new AllianceInvites();

            invites.allianceInvite = new List <AllianceInvite>();

            if (player.allianceId != 0)
            {
                if (Core.Core.Instance.invitesPerAlliance.ContainsKey(player.allianceId))
                {
                    foreach (var invite in Core.Core.Instance.invitesPerAlliance[player.allianceId])
                    {
                        invites.allianceInvite.Add(new AllianceInvite(invite, player.allianceId));
                    }
                }
            }

            if (Core.Core.Instance.invitesPerUser.ContainsKey(player.id))
            {
                foreach (var invite in Core.Core.Instance.invitesPerUser[player.id])
                {
                    invites.allianceInvite.Add(new AllianceInvite(player.id, invite));
                }
            }

            return(invites);
        }
        public void removeInviteToAlliance(int senderId, int receiverId)
        {
            if (!Core.Core.Instance.users.ContainsKey(senderId))
            {
                return;
            }
            if (!Core.Core.Instance.users.ContainsKey(receiverId))
            {
                return;
            }

            Core.User sender   = Core.Core.Instance.users[senderId];
            Core.User receiver = Core.Core.Instance.users[receiverId];

            try
            {
                SpacegameServer.Core.Alliance.removeInvitation(sender, receiver);
            }
            catch (Exception ex)
            {
                SpacegameServer.Core.Core.Instance.writeExceptionToLog(ex);
            }

            return;
        }
Beispiel #10
0
        public ActionResult Register(RegistrationRequest registrationRequest)
        {
            try
            {
                Core.User user = accessController.Register(registrationRequest);
                if (user != null)
                {
                    ViewBag.IsRegistered = true;
                    Util.SetCredentials(user);

                    string userData = JsonConvert.SerializeObject(user);


                    FormsAuthenticationTicket authTicket = new FormsAuthenticationTicket(
                        1,
                        user.Id.ToString(),                                 //user id
                        DateTime.Now,
                        DateTime.Now.AddMinutes(30),                        // expiry
                        false,                                              //do not remember
                        userData,
                        "/");

                    HttpCookie cookie = new HttpCookie(FormsAuthentication.FormsCookieName,
                                                       FormsAuthentication.Encrypt(authTicket));
                    Response.Cookies.Add(cookie);
                }
            }
            catch (Exception excp)
            {
                ViewBag.Error = excp.Message;
            }

            return(View());
        }
        public void saveFogString(int userId, string fogString, int fogVersion)
        {
            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return;
            }
            Core.User user = Core.Core.Instance.users[userId];

            if (user.fogVersion >= fogVersion)
            {
                return;
            }

            user.fogVersion = fogVersion;
            user.fogString  = fogString;

            Core.Core.Instance.dataConnection.userSaveFog(user);

            /*
             * if (!Core.Core.Instance.users.ContainsKey(senderId)) return;
             * Core.User sender = Core.Core.Instance.users[senderId];
             *
             * try
             * {
             *  SpacegameServer.Core.Alliance.changeDescription(sender, newName);
             * }
             * catch (Exception ex)
             * {
             *  SpacegameServer.Core.Core.Instance.writeExceptionToLogFile(ex);
             * }
             */
            return;
        }
Beispiel #12
0
        public string getUserDetails(int targetUserId)
        {
            BC.XMLGroups.UserDetails relations = new BC.XMLGroups.UserDetails();

            if (!Core.Core.Instance.users.ContainsKey(this.userId))
            {
                return("<relations></relations>");
            }
            if (!Core.Core.Instance.users.ContainsKey(targetUserId))
            {
                return("<relations></relations>");
            }

            Core.User user       = Core.Core.Instance.users[this.userId];
            Core.User targetUser = Core.Core.Instance.users[targetUserId];

            relations.description = targetUser.Description;
            relations.userId      = targetUser.id;


            relations.relation = Core.Core.Instance.userRelations.getUserDiplomatics(user, targetUser);


            string x = "";

            //BusinessConnector.Serialize<BC.XMLGroups.UserDetails>(relations, ref x, true);
            x = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(relations);

            return(x);
        }
        public User GetRecruiterInfo(string userName)
        {
            User recruiter = new Core.User();

            recruiter.UserName = dataTable.Rows[0]["user_name"].ToString();
            recruiter.UserId   = Convert.ToInt32(dataTable.Rows[0]["user_id"]);
            recruiter.UserType = Convert.ToByte(dataTable.Rows[0]["user_type"]);

            recruiter.FirstName   = dataTable.Rows[0]["first_name"].ToString();
            recruiter.LastName    = dataTable.Rows[0]["last_name"].ToString();
            recruiter.Email       = dataTable.Rows[0]["email"].ToString();
            recruiter.PhoneNumber = dataTable.Rows[0]["phone"].ToString();

            using (MemoryStream ms = new MemoryStream((byte[])dataTable.Rows[0]["photo"]))
            {
                var photo = new BitmapImage();
                photo.BeginInit();
                photo.CacheOption  = BitmapCacheOption.OnLoad;
                photo.StreamSource = ms;
                photo.EndInit();

                recruiter.Photo = photo;
            }

            recruiter.JobPosition = dataTable.Rows[0]["job_position"].ToString();

            recruiter.CompanyName = query.getCompanyName(Convert.ToUInt32(dataTable.Rows[0]["company_id"]));

            return(recruiter);
        }
Beispiel #14
0
        private bool CanSeeUnpublishedContents()
        {
            var context = System.Web.HttpContext.Current;

            if (context == null)
            {
                return(false);
            }

            string token = context.Request.QueryString["previewToken"];

            if (String.IsNullOrEmpty(token))
            {
                return(false);
            }

            Core.Services.SecurityService security = new Core.Services.SecurityService();
            var admCMS = new Groups.ADM_CMS();
            var admSEC = new Core.Groups.ADM_SEC();

            Core.User u = security.GetUserByAuthToken(token);
            if (u == null)
            {
                return(false);
            }

            string[] roles = security.GetUserRoles(u);
            return(roles.Contains(admCMS.UserGroupUId) || roles.Contains(admSEC.UserGroupUId));
        }
Beispiel #15
0
        private void _kinect_UserCreated(object sender, KinectUserEventArgs e)
        {
            Core.User kinect_user = _kinect.GetUser(e.User.Id);
            var       xnaUser     = new User.User(kinect_user, Content,
                                                  new Size(graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight));

            _users.Add(xnaUser);
        }
        public ActionResult Add(AddUserViewModel userViewModel)
        {
            if (userManager.HasUserName(userViewModel.UserName))
            {
                ModelState.AddModelError("UserName", "用户名已存在");
            }
            if (userManager.HasEmail(userViewModel.Email))
            {
                ModelState.AddModelError("Email", "Email已存在");
            }
            if (ModelState.IsValid)
            {
                User _user = new Core.User()
                {
                    RoleID   = userViewModel.RoleID,
                    UserName = userViewModel.UserName,
                    Name     = userViewModel.Name,
                    Sex      = userViewModel.Sex,
                    Password = Core.General.Security.Sha256(userViewModel.Password),
                    Email    = userViewModel.Email,
                    RegTime  = DateTime.Now
                };

                var _response = userManager.Add(_user);
                if (_response.Code == 1)
                {
                    return(View("Prompt", new Prompt()
                    {
                        Title = "添加用户成功",
                        Message = "您已成功添加了用户【" + _response.Data.UserName + "(" + _response.Data.Name + ")】",
                        Buttons = new List <string> {
                            "<a href=\"" + Url.Action("Index", "User") + "\" class=\"btn btn-default\">用户管理</a>",
                            "<a href=\"" + Url.Action("Details", "User", new { id = _response.Data.UserID }) + "\" class=\"btn btn-default\">查看用户</a>",
                            "<a href=\"" + Url.Action("Add", "User") + "\" class=\"btn btn-default\">继续添加</a>"
                        }
                    }));
                }
                else
                {
                    ModelState.AddModelError("", _response.Message);
                }
            }
            //角色列表
            var _roles = new RoleManager().FindList();
            List <SelectListItem> _listItems = new List <SelectListItem>(_roles.Count());

            foreach (var _role in _roles)
            {
                _listItems.Add(new SelectListItem()
                {
                    Text = _role.Name, Value = _role.RoleID.ToString()
                });
            }
            ViewBag.Roles = _listItems;
            //角色列表结束

            return(View(userViewModel));
        }
Beispiel #17
0
 public User(Core.User user, ContentManager content, Size windowSize)
 {
     // TODO: Complete member initialization
     _user      = user;
     _content   = content;
     WindowSize = windowSize;
     AddBodyParts();
     _user.Updated += Kinect_User_Updated;
 }
 /// <summary>
 /// Fetches all research for the owner of the call, or only completed specialization research if the owner asks informations about another player(userId )
 /// </summary>
 /// <param name="userId"></param>
 /// <param name="owner"></param>
 /// <returns></returns>
 public List <Core.UserResearch> getUserResearch(int userId, bool owner)
 {
     if (!Core.Core.Instance.users.ContainsKey(userId))
     {
         return(new List <Core.UserResearch>());
     }
     Core.User user = Core.Core.Instance.users[userId];
     return(user.PlayerResearch.Where(e => owner || (e.isCompleted == 1 && e.research.researchType == 10)).ToList());
 }
Beispiel #19
0
 public User(Core.User user, ContentManager content, Size windowSize)
 {
     // TODO: Complete member initialization
     _user = user;
     _content = content;
     WindowSize = windowSize;
     AddBodyParts();
     _user.Updated += Kinect_User_Updated;
 }
Beispiel #20
0
 public UserDeep(Guid?id, Core.User core) : base()
 {
     ID   = Calc.ID(id, core);
     Name = core.Name;
     Hide = core.Groupings?.Where(item => item.Action == Skelbimai.Core.SkelbimasAction.Hide)
            .Select(item => item.SkelbimasID);
     Show = core.Groupings?.Where(item => item.Action == Skelbimai.Core.SkelbimasAction.Show)
            .Select(item => item.SkelbimasID);
 }
        public string getFogString(int userId)
        {
            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return("");
            }
            Core.User user = Core.Core.Instance.users[userId];

            return(user.fogString);
        }
Beispiel #22
0
        private ClaimsIdentity GetIdentityFromUser(Models.APIContext db, Core.User user, string authenticationType)
        {
            var identity = new ClaimsIdentity(authenticationType);

            identity.AddClaim(new System.Security.Claims.Claim(ClaimTypes.Name, string.Format("{0} {1}", user.FirstName, user.LastName)));
            identity.AddClaim(new System.Security.Claims.Claim(ClaimTypes.Email, user.EmailAddress));
            identity.AddClaim(new System.Security.Claims.Claim(ClaimTypes.NameIdentifier, user.Id.ToString()));

            return(identity);
        }
        public static AllianceFullData createFullData(Core.User user)
        {
            AllianceFullData fullData = new AllianceFullData();

            fullData.allianceDiplomacy = XMLGroups.KnownAlliances.createAllianceContacts(user);
            fullData.allianceRelations = XMLGroups.AllianceUserRelations.createAllianceUserRelations(user);
            fullData.allianceInvites   = XMLGroups.AllianceInvites.createAllianceInvites(user);

            return(fullData);
        }
        public void SetLatestGalacticEvents(int userId, int LatestEventSoFar)
        {
            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return;
            }
            Core.User user = Core.Core.Instance.users[userId];

            user.LastReadGalactivEvent = LatestEventSoFar;
            Core.Core.Instance.dataConnection.saveUser(user);
        }
Beispiel #25
0
        public static string leaveAlliance(Core.User user, Core.User userToRemove, int allianceId)
        {
            string xml = "";

            Core.Alliance.leaveCheck(user, userToRemove, allianceId);

            SpacegameServer.BC.XMLGroups.AllianceFullData allianceInfo = SpacegameServer.BC.XMLGroups.AllianceFullData.createFullData(user);
            BusinessConnector.Serialize <SpacegameServer.BC.XMLGroups.AllianceFullData>(allianceInfo, ref xml, true);

            return(xml);
        }
        public void SetShowCombatFast(int userId, bool value)
        {
            if (!Core.Core.Instance.users.ContainsKey(userId))
            {
                return;
            }
            Core.User user = Core.Core.Instance.users[userId];

            user.showCombatFast = value;
            Core.Core.Instance.dataConnection.saveUser(user);
        }
        /// <summary>
        /// creates a single contact information
        /// </summary>
        /// <param name="player"></param>
        /// <param name="target"></param>
        /// <returns></returns>
        public static UserContacts createContacts(Core.User player, int target)
        {
            UserContacts knownUsers = new UserContacts();

            knownUsers.knownUser = new List <UserContact>();

            foreach (var targetRelation in Core.Core.Instance.userRelations.getDiplomatics(player, 1))
            {
                Core.User targetUser = (Core.User)targetRelation.target;


                knownUsers.knownUser.Add(
                    new UserContact(targetUser.id, targetUser.username,
                                    targetRelation.relation, targetRelation.relationSenderProposal, targetRelation.relationTargetProposal,
                                    //Math.Min(relations.Key, relations.Value), relations.Key, relations.Value,
                                    targetUser.popVicPoints,
                                    targetUser.researchVicPoints,
                                    targetUser.goodsVicPoints,
                                    targetUser.shipVicPoints,
                                    targetUser.overallVicPoints,
                                    targetUser.overallRank,
                                    targetUser.allianceId,
                                    targetUser.AiId,
                                    targetUser.AiRelation,
                                    targetUser.ProfileUrl)
                    );
            }

            /*
             * foreach(var targetRelation in Core.Core.Instance.userRelations.getUserRelationsForUser(player))
             * {
             *  //skip others if single player data is requested
             *  if (target != 0 && targetRelation.Key != target) continue;
             *  Core.User targetUser = Core.Core.Instance.users[targetRelation.Key];
             *
             *  var relations = Core.Core.Instance.userRelations.getProposals(player, targetUser);
             *
             *  knownUsers.knownUser.Add(
             *      new UserContact(targetUser.id, targetUser.username,
             *          Math.Min(relations.Key, relations.Value), relations.Key, relations.Value,
             *          targetUser.popVicPoints,
             *          targetUser.researchPoints,
             *          targetUser.goodsVicPoints,
             *          targetUser.shipVicPoints,
             *          targetUser.overallVicPoints,
             *          targetUser.overallRank,
             *          targetUser.allianceId)
             *      );
             *
             * }
             */
            return(knownUsers);
        }
Beispiel #28
0
        public static List <AllowedShipHulls> createAllowedShipHulls(Core.User player)
        {
            List <AllowedShipHulls> allowedShipHulls = new List <AllowedShipHulls>();

            foreach (var hull in Core.Core.Instance.ShipHulls.Where(e => e != null))
            {
                if (player.hasGameObjectEnabled(5, hull.id))
                {
                    allowedShipHulls.Add(new AllowedShipHulls(hull.id));
                }
            }

            return(allowedShipHulls);
        }
Beispiel #29
0
        public static List <AllowedBuilding> createAllowedBuildings(Core.User player)
        {
            List <AllowedBuilding> allowedBuildings = new List <AllowedBuilding>();

            foreach (var building in Core.Core.Instance.Buildings.Where(e => e != null))
            {
                if (player.hasGameObjectEnabled(3, building.id))
                {
                    allowedBuildings.Add(new AllowedBuilding(building.id));
                }
            }

            return(allowedBuildings);
        }
        public void LoginTests(Core.User user)
        {
            try
            {
                new BasicAuthorization(user).Login().Wait();
            }
            catch (Exception e)
            {
                Assert.Fail($"Authorization not success. User information: {user}.\n\nException: {e.Message}");
            }


            Assert.Pass();
        }
Beispiel #31
0
        public static List <AllowedModule> createAllowedModules(Core.User player)
        {
            List <AllowedModule> allowedModules = new List <AllowedModule>();

            foreach (var module in Core.Core.Instance.Modules.Where(e => e != null))
            {
                if (player.hasGameObjectEnabled(4, module.id))
                {
                    allowedModules.Add(new AllowedModule(module.id));
                }
            }

            return(allowedModules);
        }
Beispiel #32
0
        public ActionResult SocialLoginback(string code, string error, string error_reason)
        {
            var fb = new FacebookConnector();
            var wowBiz = new WoWBiz();

            var accessToken = fb.GetAccessToken(code, RedirectUri.AbsoluteUri);

            // Store the access token in the session for farther use
            Session["AccessToken"] = accessToken;

            // Get user profile from facebook
            dynamic userProfile = fb.GetUserProfile(accessToken);

            #region User Process
            var clientId = userProfile.id;
            var userProfileImage = string.Format("https://graph.facebook.com/{0}/picture", userProfile.id);
            //Create user for first times login
            var existingUser = wowBiz.GetUserByClientId((string)clientId);
            if (existingUser == null)
            {
                var user = new Core.User
                {
                    ImageUrl = userProfileImage,
                    Name = string.Format("{0} {1}", userProfile.first_name, userProfile.last_name),
                    Socials = new List<Core.Social>{
                        new Core.Social{
                            ClientId_ = clientId,
                            Email = userProfile.email,
                            Name = string.Format("{0} {1}", userProfile.first_name, userProfile.last_name),
                            Token = accessToken,
                            Type = (int)Core.Enum.SocialType.Facebook,
                        }
                    }
                };
                var success = wowBiz.CreateNewUser(user);
                existingUser = user;
            }
            else
            {
                //Update
                wowBiz.UpdateSocialToken(existingUser.Socials.First().Id, accessToken);
            }
            Session["User"] = existingUser;
            #endregion
            // Set the auth cookie
            FormsAuthentication.SetAuthCookie(userProfile.email, false);
            return RedirectToAction("Index", "Home");
        }
Beispiel #33
0
        public static void Main(string[] args)
        {
            IServerConfiguration config = Db4oClientServer.NewServerConfiguration();

            using (IObjectServer server = Db4oClientServer.OpenServer(config, YapFileName, 0))
            {
                using (IObjectContainer client = server.OpenClient())
                {
                    var pass = "******";

                    var user = new Core.User()
                    {
                        CreatedOn = DateTime.Now,
                        Email = "*****@*****.**",
                        Name = "Teste 1",
                        Password = Encoding.Unicode.GetString(new MD5CryptoServiceProvider().ComputeHash(Encoding.Unicode.GetBytes(pass)))
                    };

                    client.Store(user);
                }
            }

            //AccessRemoteServer();
            //using (IObjectServer server = Db4oClientServer.OpenServer(Db4oClientServer.NewServerConfiguration(),
            //    YapFileName, ServerPort))
            //{
            //    server.GrantAccess(ServerUser, ServerPassword);
            //    QueryRemoteServer(ServerPort, ServerUser, ServerPassword);
            //    DemonstrateRemoteReadCommitted(ServerPort, ServerUser, ServerPassword);
            //    DemonstrateRemoteRollback(ServerPort, ServerUser, ServerPassword);
            //}
        }