Beispiel #1
0
        public bool RegisterClient(UserContract userContract)
        {
            userContract.idR = 2;
            var result = new UserDao().CreateAccount(userContract);

            return(result);
        }
        public async Task <ActionResult> DeleteFeedBacks(int[] ids)
        {
            ids.CheckNotNull("ids");
            OperationResult result = await UserContract.DeleteFeedBacks(ids);

            return(Json(result.ToAjaxResult()));
        }
        /// <summary>
        /// This method is called by the AuthSvc when it receives a request to create a user.
        /// </summary>
        /// <param name="displayName">The display name</param>
        /// <param name="userName">The user name</param>
        /// <param name="passwordHash">The hashed password bytes</param>
        public virtual string CreateNewUserRequest(string displayName, string email, string userName, byte[] passwordHash)
        {
            var existingUser = UserLogic.SelectBy_UserNameNow(userName);

            if (existingUser.Count > 0)
            {
                return(CreateFail_UserNameExists);
            }
            existingUser = UserLogic.SelectBy_EmailNow(email);
            if (existingUser.Count > 0)
            {
                return(CreateFail_EmailExists);
            }


            var user = new UserContract
            {
                DisplayName = displayName,
                UserName    = userName,
                Email       = email,
                Password    = passwordHash,
                AuthToken   = Guid.NewGuid(),
                UserToken   = Guid.NewGuid(),
                IsActive    = true
            };

            var emailSent = SendActivationEmail(user);

            if (emailSent)
            {
                UserLogic.InsertNow(user);
            }

            return(emailSent ? CreateSuccess: CreateFail_CantEmail);
        }
        /// <summary>
        /// Creates an account for the current windows/forms auth user
        /// </summary>
        public virtual UserContract CreateAccountForCurrentWindowsUser()
        {
            var currentUserName        = GetCurrentUserName();
            var currentDisplayUserName = GetCurrentDisplayName();
            var currentWinSid          = GetCurrentWindowsId();
            var currentEmail           = GetCurrentEmail();

            if (string.IsNullOrEmpty(currentWinSid))
            {
                return(null);                                    // Can't enroll anonymous.
            }
            var user = new UserContract
            {
                DisplayName = currentDisplayUserName,
                UserName    = currentUserName,
                Email       = currentEmail,
                WINSID      = currentWinSid,
                IsActive    = true,
                Password    = new byte[16]
            };

            // ensure does not exist before saving new
            var existing = UserLogic.SelectBy_WINSIDNow(currentWinSid);

            if (existing.Count == 0)
            {
                UserLogic.SaveNow(user);
                return(user);
            }

            return(null); //User already exists, we didn't make one.
        }
        public async Task <IHttpActionResult> ChangeUserName(string newUserName, string password, string validateCode, string userName = "")
        {
            userName = UserContract.UserInfos.Single(x => x.Id == OperatorId).SysUser.UserName;
            var result = await UserContract.ChangeUserName(userName, newUserName, password, validateCode);

            return(Json(result.ToApiResult()));
        }
Beispiel #6
0
        public async Task <ActionResult> EditUserInfo(UserInfoEditDto dto)
        {
            dto.Id = OperatorId;
            var result = await UserContract.EditUserInfos(dto);

            return(Json(result.ToApiResult()));
        }
        protected void btnSendToRoute_Click(object sender, EventArgs e)
        {
            int fullcounter = 0;

            //move the job card routes into the meter reading routes tables and then redirect to Management console
            //first we need to check if all the instructions were filled in
            foreach (GridDataItem row in gvSearchResults.Items)
            {
                CheckBox chk = (CheckBox)row["MarkCHK"].Controls[0];
                //CheckBox tempbox = (CheckBox)row.FindControl("CheckBox1");
                Classes.IDBHandler             db   = new Classes.DBHandler();
                Common.ReadingsDetailDBHandler rddb = new Common.ReadingsDetailDBHandler();

                if (chk.Checked)
                {
                    //string statusdescr = gvSearchResults.SelectedItems[row.RowIndex].OwnerTableView.DataKeyValues[3].ToString();
                    int jobHeaderID = Convert.ToInt32(row.GetDataKeyValue("JobCardHeaderID").ToString());

                    //check instructions
                    int counter = 0;
                    counter = rddb.CheckInstructions(jobHeaderID);
                    if (counter == 0)
                    {
                        //all instructions have been inserted. move the routes.
                        Boolean correct = rddb.MoveJobCardsToRoutes(jobHeaderID);

                        //change contractID
                        int ContractID = rddb.GetWorkOrderContract();
                        Users_UserDetail                   uud   = (Users_UserDetail)Session["userDetails"];
                        Common.ICommonDBHandler            cdb   = new Common.CommonDBHandler();
                        UserContract                       uclst = cdb.GetUserContractList(uud).Where(x => x.EnableContract == true && x.ClientContract.ContractActive == true && x.ContractID == ContractID).FirstOrDefault();
                        Common.CommonTasks.UserContractDet ucd   = cdb.LoadUserContractDetByUserContractID(uclst.UserContractID);
                        Session["UserContractDet"] = ucd;

                        //Redirect to Management Console
                        Response.Redirect("RouteManagementConsole.aspx");
                    }
                    else
                    {
                        //there are missing instructions - dont allow.
                        lblError.Text    = "Cannot transfer routes, please ensure you have added instructions to each meter.";
                        lblError.Visible = true;
                    }
                    fullcounter++;
                }
            }

            if (fullcounter > 0)
            {
                gvSearchResults.Rebind();
            }
            else
            {
                lblError.Text      = "Please select at least one item to send.";
                lblError.ForeColor = System.Drawing.Color.Red;
                lblError.Visible   = true;
            }

            //Response.Redirect("RouteManagementConsole.aspx");
        }
Beispiel #8
0
        public async Task <IHttpActionResult> AddFeedBack(FeedBackDto dto)
        {
            dto.UserInfoId = OperatorId;
            var result = await UserContract.SaveFeedBacks(dtos : dto);

            return(Json(new ApiResult(result.ResultType, "反馈成功")));
        }
Beispiel #9
0
        public async Task <IHttpActionResult> EditUserInfo(string data)
        {
            var dto    = JsonToEntity <UserInfoEditDto>(data);
            var result = await UserContract.EditUserInfos(dto);

            return(Json(new ApiResult(result.ResultType, "信息更新成功")));
        }
Beispiel #10
0
        public void BulkInsert()
        {
            const int perInsertCount = 100000;
            using (EFTestContext context = new EFTestContext())
            {
                for (int i = 0; i < 100; i++)
                {
                    List<UserContract> users = new List<UserContract>(perInsertCount + 1);
                    for (int j = 0; j < perInsertCount; j++)
                    {
                        var user = new UserContract
                        {
                            Name = "nlh" + j + 1,
                            CardId = "11111",
                            Password = "******",
                            CreatedOn = DateTime.Now
                        };
                        //context.User.Add(user);   //直接插入上下文,下面调用SaveChanges(),BulkSaveChanges()更新
                        users.Add(user);
                    }
                    //context.SaveChanges();
                    context.BulkInsert(users);  //context.BulkSaveChanges();  没有context.BulkInsert(users);快

                }
            }
        }
Beispiel #11
0
        /// <summary>
        /// Updates the profile of an <see cref="UserContract"/>.
        /// </summary>
        /// <param name="user">The <see cref="UserContract"/>.</param>
        public void UpdateMyProfile(UserContract user)
        {
            this.ManageException(
                action: () =>
            {
                if (user == null)
                {
                    throw new InvalidOperationException(message: "user can't be null");
                }

                if (user.UserId <= 0)
                {
                    throw new InvalidOperationException(message: "unknown user");
                }

                if (user.UserId != this.currentUserId)
                {
                    throw new InvalidOperationException(message: "not allowed to update profile");
                }

                if (this.store.UserExist(userName: user.UserName))
                {
                    var knownUser = this.store.LoadUser(userName: user.UserName);
                    if (knownUser.UserId != user.UserId)
                    {
                        throw FaultExceptionHelper.From(error: ErrorType.AlreadyConnectedUser, exception: null);
                    }
                }

                this.store.AddOrUpdateUser(user: user.FromContract());
                this.notificationManager.NotifyUserChange(userId: user.UserId);
            },
                description: "UpdateMyProfile");
        }
Beispiel #12
0
        public bool CreateAccount(UserContract userContract)
        {
            var data = new User();

            data.nameUser = userContract.UserName;
            data.email    = userContract.email;
            data.pwd      = userContract.Password;
            data.idR      = userContract.idR;
            data.active   = true;

            db.Users.Add(data);
            try
            {
                if (db.SaveChanges() > 0)
                {
                    return(true);
                }
                else
                {
                    return(true);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                return(false);
            }
        }
Beispiel #13
0
 public RestClient(UserContract user, string appId = null, string baseUrl = null)
 {
     this.user    = user;
     this.baseUrl = baseUrl ?? SiteSettings.Instance.WebApi.Domain;
     this.appId   = appId ?? SiteSettings.Instance.WebApi.AppId;
     //AddHeader("Basic", Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userId + ":")));
 }
        /// <summary>
        /// Insert by providing a populated data contract
        /// </summary>
        /// <param name="row">The table row data to use</param>
        /// <param name="connection">The SqlConnection to use</param>
        /// <param name="transaction">The SqlTransaction to use</param>
        /// <returns>1, if insert was successful</returns>
        public int Insert(UserContract row, SqlConnection connection, SqlTransaction transaction)
        {
            int?result = null;

            using (
                var cmd = new SqlCommand("[Auth].[User_Insert]", connection)
            {
                CommandType = CommandType.StoredProcedure, Transaction = transaction
            })
            {
                cmd.Parameters.AddRange(new[] {
                    new SqlParameter("@UserName", row.UserName)
                    ,
                    new SqlParameter("@Password", row.Password)
                    ,
                    new SqlParameter("@DisplayName", row.DisplayName)
                    ,
                    new SqlParameter("@Email", row.Email)
                    ,
                    new SqlParameter("@AuthToken", row.AuthToken)
                    ,
                    new SqlParameter("@UserToken", row.UserToken)
                    ,
                    new SqlParameter("@FailedLogins", row.FailedLogins)
                    ,
                    new SqlParameter("@IsActive", row.IsActive)
                    ,
                    new SqlParameter("@WINSID", row.WINSID)
                });

                result     = (int?)cmd.ExecuteScalar();
                row.UserId = result;
            }
            return(result != null ? 1 : 0);
        }
        public IActionResult Insert([FromBody] UserVM user)
        {
            if (user.UserName is null || user.Password is null)
            {
                return(BadRequest("value is null."));
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            Tuple <AuthenticationResult, User> authResult = UserContract.AddUser(user.Name, user.FamilyName, user.UserName, user.Password, user.Email, user.BirthDate.Value);

            if (authResult.Item1.Code != AuthenticationResultCode.AuthenticationSuccess)
            {
                return(BadRequest(
                           new FailedLoginResponseModel()
                {
                    code = authResult.Item1.Code,
                    authenticationResult = AuthenticationContract.GetAuthenticationResultMessage(authResult.Item1.Code, "fa-IR"),
                    additionalInformation = authResult.Item1.AdditionalErrorMessage
                }
                           ));
            }
            //return CreatedAtRoute("addUser", new { controller = "User", id = authResult.Item2.Id }, (User)authResult.Item2);
            return(Ok());
        }
Beispiel #16
0
        internal async Task <string> CreateUserInApim(UserContract userContract)
        {
            string userId = Guid.NewGuid().ToString("N");

            UserContractForCreate userProperties      = new UserContractForCreate();
            PropertiesForCreate   propertiesForCreate = new PropertiesForCreate();

            propertiesForCreate.Email     = userContract.Properties.Email;
            propertiesForCreate.FirstName = userContract.Properties.FirstName;
            propertiesForCreate.LastName  = userContract.Properties.LastName;
            userProperties.Properties     = propertiesForCreate;



            var json = JsonConvert.SerializeObject(userProperties);

            json = json.Replace("Properties", "properties");
            json = json.Replace("Identities", "identities");
            json = json.Replace("Id", "id");
            json = json.Replace("Provider", "provider");

            var data = new StringContent(json, Encoding.UTF8, "application/json");

            string response = await ExecutePatchRequest("", "https://management.azure.com/subscriptions/", APIMSubscriptionId, APIMResourceGroup, APIMServiceName, "/users/" + userId, "?api-version=2019-12-01", data);

            /*if(userContract.Properties != null && userContract.Properties.Groups != null && userContract.Properties.Groups.value != null)
             * {
             *  foreach (GroupContract group in userContract.Properties.Groups.value)
             *  {
             *      string groupResponse = await CreateUserGroup(group.Id, userContract.Id);
             *  }
             * }*/
            return(response);
        }
Beispiel #17
0
        public async Task <IActionResult> Accept(UserContractVM vM)
        {
            if (ModelState.IsValid)
            {
                var request = context.Requests.FirstOrDefault(i => i.Id == vM.requestId);
                request.IsAccepted = true;
                context.SaveChanges();
                var userId       = request.AppUserId;
                var userContarct = new UserContract
                {
                    AppUserId  = userId,
                    Agreement  = vM.Agreement,
                    Amount     = vM.Amount,
                    MonthCount = vM.MonthCount
                };
                context.UserContracts.Add(userContarct);
                context.SaveChanges();
                var user = await userManager.FindByIdAsync(userId);

                user.Amount = vM.Amount;
                context.SaveChanges();
                return(RedirectToAction("Accept", "Bank"));
            }
            return(View(vM));
        }
Beispiel #18
0
        public UserDTO RegisterUser(UserContract user, PatientDetailContract patient = null)
        {
            try
            {
                var userContext = mapper.Map <User>(user);
                userContext.UserTypeNo = (int)user.UserType;
                var result         = context.Register(userContext);
                var patientContext = patient != null?mapper.Map <PatientDetail>(patient) : new PatientDetail();

                if (result.UserId > 0)
                {
                    if (patient != null)
                    {
                        patientContext.UserID = result.UserId;
                        patientContext        = context.RegisterPatient(patientContext);
                    }
                    else
                    {
                        return(new UserDTO {
                            Valid = false
                        });
                    }
                }

                var dto = mapper.MergeInto <UserDTO>(result, patientContext);
                dto.Valid = true; // AutoLogin

                return(dto);
            }
            catch (Exception ex)
            {
                throw new ApplicationException("User account not created!", ex);
            }
        }
        public AlbumCollection(UserContract user, AlbumCollectionRouteParams routeParams)
        {
            User        = user;
            RouteParams = routeParams;

            FilterByPurchaseStatus = routeParams.purchaseStatus ?? PurchaseStatus.Nothing;
        }
Beispiel #20
0
        public async Task Create100APIMUsers(UserNormalization un)
        {
            UserContract userContractbase = GetUserContractFor(un.Email);
            string       firstName        = userContractbase.Properties.FirstName;
            string       email            = userContractbase.Properties.Email;

            UserContract userContract = userContractbase;

            for (int iter100 = 0; iter100 < 100; iter100++)
            {
                userContract.Properties.FirstName        = firstName + iter100;
                userContract.Properties.Email            = email.Replace("@", iter100 + "@");
                userContract.Properties.Identities[0].Id = userContract.Properties.Email;

                foreach (UserNormalizationStatus uns in un.UsersStatus)
                {
                    Console.WriteLine("        Creating user in service: " + uns.APIMName);
                    APIMService apimClient = apims[0];
                    string      response   = await apimClient.CreateUserInApim(userContract);

                    Console.WriteLine("        Result: " + response.Substring(0, 30) + (response.Length > 30 ? "..." : ""));
                    Console.WriteLine("");
                }
            }
        }
Beispiel #21
0
 public UserIconLink_UserContractViewModel(UserContract user, int size = ImageHelper.UserTinyThumbSize, bool userInfo = false, bool tooltip = false)
 {
     User     = user;
     Size     = size;
     UserInfo = userInfo;
     Tooltip  = tooltip;
 }
Beispiel #22
0
        public async Task <UserContract> UpdateUserProfile(UserContract user)
        {
            try
            {
                _telemetryClient.TrackEvent("UserController UpdateUserProfile invoked");

                var currentUserId = await ValidateAndReturnCurrentUserId();

                if (!currentUserId.Equals(user.RegistrationReference))
                {
                    throw ServiceExceptions.NotAllowed();
                }

                var existingUser = await _repository.UpdateUser(user);

                return(existingUser);
            }
            catch (DataLayerException ex)
            {
                _telemetryClient.TrackException(ex);

                if (ex.Error == DataLayerError.Unknown)
                {
                    throw ServiceExceptions.UnknownInternalFailureException(ServiceExceptions.Source);
                }

                throw ServiceExceptions.DataLayerException(ex.Message);
            }
        }
Beispiel #23
0
        private void ajaxSaveContract()
        {
            HttpContext.Current.Response.ContentType = "application/json";
            List <ajaxContractGZ.RequestDataJSON> requestDataJsonList = ajaxContractGZ.JSONToObject <List <ajaxContractGZ.RequestDataJSON> >(HttpUtility.UrlDecode(new StreamReader(HttpContext.Current.Request.InputStream).ReadToEnd()));

            ajaxContractGZ.RequestDataJSON requestDataJson1 = new ajaxContractGZ.RequestDataJSON();
            try
            {
                UserContract list = new UserContract();
                list.Type     = 2;
                list.ParentId = Convert.ToInt32(this.AdminId);
                list.UserId   = Convert.ToInt32(requestDataJsonList[0].userId);
                List <UserContractDetail> userContractDetailList = new List <UserContractDetail>();
                for (int index = 0; index < requestDataJsonList.Count; ++index)
                {
                    ajaxContractGZ.RequestDataJSON requestDataJson2 = requestDataJsonList[index];
                    userContractDetailList.Add(new UserContractDetail()
                    {
                        MinMoney = Convert.ToDecimal(requestDataJson2.money),
                        Money    = Convert.ToDecimal(requestDataJson2.per)
                    });
                }
                list.UserContractDetails = userContractDetailList;
                this._response           = new ContractGzDAL().SaveContract(list) <= 0 ? this.JsonResult(0, "分配契约失败!") : this.JsonResult(1, "分配契约成功!");
            }
            catch (Exception ex)
            {
                this._response = this.JsonResult(0, "分配契约失败!");
            }
        }
        public ExternalRepositoryStatisticsContract GetExternalRepositoryStatistics(int externalRepositoryId)
        {
            var work = new GetExternalRepositoryStatisticsWork(m_externalRepositoryRepository, m_importHistoryRepository, externalRepositoryId);

            work.Execute();


            DateTime?    lastUpdateDate         = null;
            bool?        lastUpdateIsSuccessful = null;
            UserContract updatedByUser          = null;

            if (work.LastImportHistory != null)
            {
                updatedByUser          = work.LastImportHistory.CreatedByUser == null ? null : m_mapper.Map <UserContract>(work.LastImportHistory.CreatedByUser);
                lastUpdateDate         = work.LastImportHistory.Date;
                lastUpdateIsSuccessful = work.LastImportHistory.Status != ImportStatusEnum.Failed;
            }

            return(new ExternalRepositoryStatisticsContract
            {
                TotalImportedItems = work.TotalImportStatistics.NewItems,
                TotalItemsInLastUpdate = work.LastImportStatisticsResult.TotalItems,
                NewItemsInLastUpdate = work.LastImportStatisticsResult.NewItems,
                UpdatedItemsInLastUpdate = work.LastImportStatisticsResult.UpdatedItems,
                UpdatedBy = updatedByUser,
                LastUpdateDate = lastUpdateDate,
                IsSuccessful = lastUpdateIsSuccessful
            });
        }
Beispiel #25
0
        public static async void TestCall()
        {
            var httpClient  = new MainHttpClient("https://xx.xxxxx.xxx/OAuth/api/");
            var classToPost = new SigIn {
                UserName = "******", Password = "******"
            };


            var resultSignIn = await httpClient.Invoke <SigIn, SignInResult>("authentication/sign-in",
                                                                             System.Net.Http.HttpMethod.Post,
                                                                             classToPost);

            if (resultSignIn.Response.IsSuccessStatusCode)
            {
                //RICERCO DA AUTENTICATO
                var auth         = new AuthenticationHeaderValue(resultSignIn.Data.TokenType, resultSignIn.Data.AccessToken);
                var resultSearch = await httpClient.Invoke <SigIn, List <UserContract> >("user/search",
                                                                                         System.Net.Http.HttpMethod.Post,
                                                                                         classToPost,
                                                                                         auth);

                var classToPost2 = new UserContract();

                var deleteResult = await httpClient.InvokeNoResponse <UserContract>("user/delete",
                                                                                    System.Net.Http.HttpMethod.Post,
                                                                                    classToPost2,
                                                                                    auth);

                var user = await httpClient.InvokeNoRequest <UserContract>("user/get",
                                                                           System.Net.Http.HttpMethod.Get,
                                                                           "?id=1",
                                                                           auth);
            }
        }
Beispiel #26
0
        public int SaveContract(UserContract list)
        {
            int num = 0;

            if (list.UserContractDetails.Count > 0)
            {
                using (SqlConnection sqlConnection = new SqlConnection(ComData.connectionString))
                {
                    sqlConnection.Open();
                    SqlCommand sqlCommand = new SqlCommand();
                    sqlCommand.Connection = sqlConnection;
                    try
                    {
                        sqlCommand.CommandText = string.Format("delete from [N_UserContract] where Type=1 and UserId={0}", (object)list.UserId);
                        sqlCommand.ExecuteScalar();
                        sqlCommand.CommandText  = string.Format("INSERT INTO [N_UserContract]([Type],[ParentId],[UserId],[IsUsed],[STime]) VALUES (1,{0},{1},0,getdate())", (object)list.ParentId, (object)list.UserId);
                        sqlCommand.CommandText += " SELECT SCOPE_IDENTITY()";
                        num = Convert.ToInt32(sqlCommand.ExecuteScalar());
                        sqlCommand.CommandText = string.Format("delete from [N_UserContractDetail] where UcId={0}", (object)num);
                        sqlCommand.ExecuteScalar();
                        foreach (UserContractDetail userContractDetail in list.UserContractDetails)
                        {
                            sqlCommand.CommandText = string.Format("INSERT INTO [N_UserContractDetail]([UcId],[MinMoney],[Money],[Sort]) VALUES ({0},{1},{2},0)", (object)num, (object)userContractDetail.MinMoney, (object)userContractDetail.Money);
                            sqlCommand.ExecuteScalar();
                        }
                    }
                    catch (Exception ex)
                    {
                        new LogExceptionDAL().Save("系统异常", ex.Message);
                        num = 0;
                    }
                }
            }
            return(num);
        }
Beispiel #27
0
        public static UserContract ToContract(this UM_User entity)
        {
            if (entity == null)
            {
                return(null);
            }

            var contract = new UserContract();

            contract.Address                = entity.Address;
            contract.DateChanged            = entity.DateChanged;
            contract.DateCreated            = entity.DateCreated;
            contract.DateDeleted            = entity.DateDeleted;
            contract.Email                  = entity.Email;
            contract.FirstName              = entity.FirstName;
            contract.ID                     = entity.ID;
            contract.LastName               = entity.LastName;
            contract.LoginName              = entity.LoginName;
            contract.Password               = entity.Password;
            contract.IsActive               = entity.IsActive;
            contract.IsSuperAdmin           = entity.IsSuperAdmin;
            contract.PasswordExpirationDate = entity.PasswordExpirationDate;
            contract.UserCategoryID         = entity.UserCategoryID;

            return(contract);
        }
Beispiel #28
0
 public FavoriteSongs(UserContract user, SongVoteRating rating, RatedSongForUserSortRule?sort, bool?groupByRating)
     : this()
 {
     GroupByRating = groupByRating;
     Rating        = rating;
     Sort          = sort;
     User          = user;
 }
Beispiel #29
0
        public UserContract GetUserObject(string UserName)
        {
            UserContract returncontract = new UserContract();

            returncontract.UserObject = UserRepo.GetUserObject(UserName);

            return(returncontract);
        }
Beispiel #30
0
 public byte[] GetFile(UserContract userContract, FileMessageDto file)
 {
     using (Context db = new Context(ServerHost.Settings.Ef))
     {
         byte[] a = db.FileMessages.Where(_ => _.Date == file.Date && _.User.Name == file.Owner.Name && _.FileName == file.FileName).Select(_ => _.Content.Content).FirstOrDefault();
         return(a);
     }
 }
Beispiel #31
0
 public FavoriteSongs(UserContract user, SongVoteRating rating, SongSortRule sort, bool groupByRating)
     : this()
 {
     GroupByRating = groupByRating;
     Rating        = rating;
     Sort          = sort;
     User          = user;
 }
Beispiel #32
0
 public int InsertUseByEF(int i)
 {
     using (EFTestContext context = new EFTestContext())
     {
         var user = new UserContract
         {
             Name = "InsertUseByEF" + i,
             CardId = "11111",
             Password = "******",
             CreatedOn = DateTime.Now
         };
         context.User.Add(user);
         return context.SaveChanges();
     }
 }
 public TestContract Post(Uri uri, UserContract contract)
 {
     return MakeApiPostRequestSync<UserContract, TestContract>(uri, contract, null).Value;
 }
 async public Task<TestContract> PutAsync(Uri uri, UserContract contract)
 {
     return await MakeApiPutRequestAsync<UserContract, TestContract>(uri, contract, null);
 }