public async Task SetTokenAsync(User user, string loginProvider, string name, string value, CancellationToken cancellationToken)
{
if (cancellationToken != null)
{
cancellationToken.ThrowIfCancellationRequested();
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrWhiteSpace(loginProvider))
{
throw new ArgumentNullException(nameof(loginProvider));
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentNullException(nameof(name));
}
var userToken = new UserToken
{
LoginProvider = loginProvider,
Name = name,
Value = value,
UserId = user.Id
};
await _userTokenService.AddAsync(userToken);
return;
}
public async Task AddProjectAsync([FromBody] ExtendedTask item)
{
await taskService.AddAsync(item.Task);
var task = await taskService.GetAsync(el =>
el.Name == item.Task.Name &&
el.Description == item.Task.Description &&
el.DateStart == item.Task.DateStart &&
el.Status == item.Task.Status);
ProjectTask tmp = await projectTaskService.GetAsync(el =>
item.IdUser == el.IdUser &&
item.IdProject == el.IdProject &&
task.IdTask == el.IdTask);
if (tmp == null)
{
await projectTaskService.AddAsync(new ProjectTask
{
IdProject = item.IdProject,
IdUser = item.IdUser,
DateStart = item.Task.DateStart,
IdTask = task.IdTask
});
}
}
public async Task <IActionResult> Save(Appuser appuser)
{
var newperson = await _appuserService.AddAsync(appuser);
return(Ok(newperson));
}
public async Task <IActionResult> Post([FromBody] RoundDto dto)
{
var round = _mapper.Map <Round>(dto);
await _roundService.AddAsync(round);
return(Created("localhost", ""));
}
public async Task <IActionResult> Post([FromBody] PredictionDto dto)
{
var prediction = _mapper.Map <Prediction>(dto);
await _predictionService.AddAsync(prediction);
return(Created("localhost", ""));
}
private async Task Add()
{
var viewModel = GetViewModel();
var group = _groupMenu.GetFromInput(viewModel);
await _groupService.AddAsync(group);
}
public async Task <IActionResult> Post([FromBody] BranchOfficeDto value)
{
if (value == null)
{
return(InvalidRequestBodyJson(nameof(BranchOfficeDto)));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!CheckTimeZoneCode(value.TimeZoneId))
{
AddErrors(new [] { $"Unknown time zone code specified: {value.TimeZoneId}" });
}
var newBranchOffice = Mapper.Map <BranchOffice>(value);
newBranchOffice.TenantId = _tenantIdProvider.GetTenantId();
await _branchOfficeService.AddAsync(newBranchOffice);
return(Created(nameof(GetBranchOffice), new CreatedWithGuidDto {
Id = newBranchOffice.Id
}));
}
public async Task AddToRoleAsync(User user, string roleName, CancellationToken cancellationToken)
{
if (cancellationToken != null)
{
cancellationToken.ThrowIfCancellationRequested();
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrWhiteSpace(roleName))
{
throw new ArgumentNullException(nameof(roleName));
}
var role = await _roleService.GetSingleAsync(i => i.Name == roleName);
await _userRoleService.AddAsync(new UserRole()
{
UserId = user.Id,
RoleId = role.Id,
});
return;
}
public void AddUser([FromBody] User user)
{
var sha256 = new SHA256Managed();
user.Password = Convert.ToBase64String(sha256.ComputeHash(Encoding.UTF8.GetBytes(user.Password)));
userService.AddAsync(user);
}
public async Task <JsonResult> AddEducationDetails(EducationDetailsResource educationDetailsResource)
{
if (ModelState.IsValid)
{
var userid = System.Web.HttpContext.Current.User.Identity.GetUserId();
var educationdetails = Mapper.Map <EducationDetailsResource, EducationDetails>(educationDetailsResource);
educationdetails.EducationTypeId = educationDetailsResource.EducationTypeId;
educationdetails.InstituteName = educationDetailsResource.InstituteName;
educationdetails.YearFromId = educationDetailsResource.YearFromId;
educationdetails.CreatedDate = DateTime.Now;
educationdetails.UpdatedDate = DateTime.Now;
educationdetails.UserId = userid;
educationdetails.YearToId = educationDetailsResource.YearToId;
educationdetails.ApplicationUserId = userid;
educationdetails.Status = true;
await _EducationDetailsService.AddAsync(educationdetails);
_EducationDetailsService.UnitOfWorkSaveChanges();
return(Json("Success"));
}
return(Json("Error"));
}
public async Task <HttpResponseMessage> Post(FileModel model)
{
var userFile = new DomainUserFile
{
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
UserId = UserId,
FileUri = model.File.Uri,
ContentType = model.File.ContentType,
FileLength = model.File.Length,
FileName = model.Name
};
userFile = await _userFileRepository.AddAsync(userFile);
var file = new File
{
ContentType = userFile.ContentType,
Name = userFile.FileName,
Uri = userFile.FileUri,
Id = userFile.FileId,
Length = userFile.FileLength
};
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, file);
response.SetLastModifiedDate(userFile.Modified);
return(response);
}
public async Task <IActionResult> Save(Person person)
{
// normally we should use dto s but i will be doing that later
var _person = await _personService.AddAsync(person);
return(Ok(_person));
}
public virtual async Task <IHttpActionResult> Post(TEntity entity)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _service.AddAsync(entity, User.Identity.Name?.Split("\\".ToCharArray()).LastOrDefault());
if (_service.Errors.Any())
{
return(RetrieveErrorResult(_service.Errors));
}
var castkey = _service.GetEntityIdObject(entity) as int?;
// If a logging service has been injected then use it.
if (_logService != null && castkey != null)
{
//await _logService.InfoAsync(entity, (int)_service.GetEntityIdObject(entity), EventType.Added, loggedInUserName: User?.Identity?.Name, useToString: true);
}
return(Created(result));
}
catch (Exception ex)
{
_logService?.Info(ex);
return(InternalServerError(ex));
}
}
public async Task <IActionResult> Post(TeamDto dto)
{
var team = _mapper.Map <Team>(dto);
await _teamService.AddAsync(team);
return(Created("localhost", ""));
}
public async Task <IActionResult> Post([FromBody] ScoreDto dto)
{
var score = _mapper.Map <Score>(dto);
await _scoreService.AddAsync(score);
return(Created("localhost", ""));
}
public async Task <IActionResult> Save(Person person)
{
var newperson = await _personService.AddAsync(person);
return(Ok(newperson));
}
public async Task <IActionResult> Post([FromBody] SportDto dto)
{
var sport = _mapper.Map <Sport>(dto);
await _sportService.AddAsync(sport);
return(Created("localhost", ""));
}
public async Task <ActionResult> AddVaccine(int patientId, [FromBody] VaccineDto vaccine)
{
vaccine.PatientId = patientId;
var res = await vaccineService.AddAsync(vaccine);
return(Created($"/api/patient/{patientId}/vaccine/{res.Id}", res));
}
public async Task <IActionResult> Post([FromBody] MatchDto dto)
{
var match = _mapper.Map <Match>(dto);
await _matchService.AddAsync(match);
return(Created("localhost", ""));
}
public async Task <IActionResult> CommentAddOrEdit([FromForm] CommentViewModel model)
{
try
{
if (ModelState.IsValid)
{
var orderItem = await _orderItemService.SingleOrDefaultAsync(p => p.Id == model.OrderItemId);
model.Rating.ProductId = orderItem.ProductId;
model.Rating.OrderItemId = orderItem.Id;
await _orderItemService.AddComment(model.OrderItemId);
if (model.Rating.Id == 0)
{
model.Rating.CreationDate = DateTime.Now;
await _ratingService.AddAsync(_mapper.Map <Rating>(model.Rating));
}
else
{
model.Rating.DateOfUpdate = DateTime.Now;
_ratingService.Update(_mapper.Map <Rating>(model.Rating));
}
return(Json(new { isValid = true, success = true, message = Messages.JSON_CREATE_MESSAGE("Değerlendirme"), redirectUrl = "/my-orders" }));
}
return(Json(new { isValid = false, success = false, message = Messages.JSON_CREATE_MESSAGE("Değerlendirme", false), redirectUrl = "/my-orders" }));
}
catch (Exception)
{
return(Json(new { isValid = false, success = false, message = Messages.JSON_CREATE_MESSAGE("Değerlendirme", false), redirectUrl = "/my-orders" }));
}
}
public async Task Add_IfModelWasAlreadyAdded_ShouldThrowException(IService <T> service)
{
//var posts = await service.GetAllAsync().SyncResult();
var postAlreadyAdded = service.GetAllAsync().SyncResult().First();
await Assert.ThrowsAsync <Exception>(async() => await service.AddAsync(postAlreadyAdded));
}
public void Get_IfAddedModel_ShouldReturnTheAddedOne(IService <T> service, T modelToBeAdded)
{
service.AddAsync(modelToBeAdded).Wait();
var gotModel = service.GetAsync(modelToBeAdded.Id).SyncResult();
Assert.Equal(modelToBeAdded.Id, gotModel.Id);
}
public void Get_IfAddedModel_ShouldReturnNotNullOne(IService <T> service, T modelToBeAdded)
{
service.AddAsync(modelToBeAdded).Wait();
var gotModel = service.GetAsync(modelToBeAdded.Id).SyncResult();
Assert.NotNull(gotModel);
}
public async Task <IdentityResult> CreateAsync(Role role, CancellationToken cancellationToken)
{
try
{
if (cancellationToken != null)
{
cancellationToken.ThrowIfCancellationRequested();
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
await _roleService.AddAsync(role);
return(IdentityResult.Success);
}
catch (Exception ex)
{
return(IdentityResult.Failed(new IdentityError {
Code = ex.Message, Description = ex.Message
}));
}
}
public async Task AddClaimAsync(Role role, Claim claim, CancellationToken cancellationToken = default(CancellationToken))
{
if (cancellationToken != null)
{
cancellationToken.ThrowIfCancellationRequested();
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (claim == null)
{
throw new ArgumentNullException(nameof(claim));
}
var roleClaimEntity = new RoleClaim
{
ClaimType = claim.Type,
ClaimValue = claim.Value,
RoleId = role.Id
};
await _roleClaimService.AddAsync(roleClaimEntity);
return;
}
public async Task <IActionResult> AddSemester(SemesterModel model)
{
try
{
var OperationType = _session.GetString("OperationType");
var semester = new Semester();
string mesaj = "";
//Yeni Kayıt İse ekle
if (OperationType == Constants.OperationType.Insert)
{
#region Semester Sistemde Var Mı Kontrolü
semester = await _semesterService.SingleOrDefaultAsync(x => x.Name == model.Name && x.SemesterType == model.SemesterType && x.IsDeleted == false);
if (semester != null)
{
return(Json(new JsonMessage {
HataMi = true, Baslik = "İşlem Başarısız", Mesaj = "Eklemek istediğiniz özelliklere sahip semester sistemde zaten mevcut."
}));
}
#endregion
#region Semester Ekle
semester = new Semester
{
Name = model.Name,
SemesterType = model.SemesterType,
Code = model.Code,
IsDeleted = false
};
await _semesterService.AddAsync(semester);
mesaj = "Yeni Semester Başarıyle Eklendi.";
#endregion
}
if (OperationType == Constants.OperationType.Update)
{
#region Update İşlemi
semester = await _semesterService.GetByIdAsync(model.Id);
semester.Name = model.Name;
semester.SemesterType = model.SemesterType;
semester.Code = model.Code;
_semesterService.Update(semester);
mesaj = "Yeni Semester Başarıyle Güncellendi.";
#endregion
}
return(Json(new JsonMessage {
HataMi = false, Baslik = "İşlem Başarılı", Mesaj = mesaj
}));
}
catch (Exception ex)
{
return(Json(new JsonMessage {
HataMi = true, Baslik = "İşlem Başarısız", Mesaj = "İşlem Sırasında Hata Oluştu."
}));
}
}
public void Delete_IfAddedModelDeleted_ShouldNotBeFoundByGetAndGetAll(IService <T> service, T modelToBeDeleted)
{
service.AddAsync(modelToBeDeleted).Wait();
service.DeleteAsync(modelToBeDeleted.Id).Wait();
Assert.Null(service.GetAsync(modelToBeDeleted.Id).SyncResult());
Assert.DoesNotContain(service.GetAllAsync().SyncResult(), p => p.Id == modelToBeDeleted.Id);
}
public async Task <IActionResult> AddProgram(ProgramModel model)
{
try
{
var OperationType = _session.GetString("OperationType");
var program = new Programs();
string mesaj = "";
//Yeni Kayıt İse ekle
if (OperationType == Constants.OperationType.Insert)
{
#region Program Sistemde Var Mı Kontrolü
program = await _programService.SingleOrDefaultAsync(x => x.Name == model.Name || x.Code == model.Code && x.IsDeleted == false);
if (program != null)
{
return(Json(new JsonMessage {
HataMi = true, Baslik = "İşlem Başarısız", Mesaj = "Eklemek istediğiniz özelliklere sahip program sistemde zaten mevcut."
}));
}
#endregion
#region Program Ekle
program = new Programs
{
Name = model.Name,
Code = model.Code,
IsDeleted = false
};
await _programService.AddAsync(program);
mesaj = "Yeni Program Başarıyle Eklendi.";
#endregion
}
if (OperationType == Constants.OperationType.Update)
{
#region Update İşlemi
program = await _programService.GetByIdAsync(model.Id);
program.Name = model.Name;
program.Code = model.Code;
_programService.Update(program);
mesaj = "Yeni Program Başarıyle Güncellendi.";
#endregion
}
return(Json(new JsonMessage {
HataMi = false, Baslik = "İşlem Başarılı", Mesaj = mesaj
}));
}
catch (Exception ex)
{
return(Json(new JsonMessage {
HataMi = true, Baslik = "İşlem Başarısız", Mesaj = "İşlem Sırasında Hata Oluştu."
}));
}
}
public virtual async Task <TResponseModel> Add(
[FromBody] TRequestModel requestModel)
{
var model = RequestModelMapper.Map(requestModel);
model = await Service.AddAsync(model);
return(ResponseModelMapper.Map(model));
}
private async void button1_Click(object sender, EventArgs e)
{
var added = await _goodTypeService.AddAsync(new GoodTypeDto()
{
Name = textBox1.Text
});
MessageBox.Show($"Added {added}");
}
