public async Task <OutputResponse> Update(ResourceDTO resource)
{
var resourceToUpdate = await _context.Resources.FirstOrDefaultAsync(x => x.ResourceId.Equals(resource.ResourceId));
if (resourceToUpdate == null)
{
return(new OutputResponse
{
IsErrorOccured = true,
Message = "Resource specified does not exist, update cancelled"
});
}
//update details
resourceToUpdate.ResourceName = resource.ResourceName;
resourceToUpdate.RowAction = "U";
resourceToUpdate.ModifiedBy = resource.CreatedBy;
resourceToUpdate.DateModified = DateTime.UtcNow.AddHours(2);
await _context.SaveChangesAsync();
return(new OutputResponse
{
IsErrorOccured = false,
Message = MessageHelper.UpdateSuccess
});
}
protected void btnRegister_Click(object sender, EventArgs e)
{
// Open SQL connection
SQLConnector con = new SQLConnector();
string EncryptedPassword = FormsAuthentication.HashPasswordForStoringInConfigFile(txtPassword.Text, "SHA1");
ResourceDTO NewResource = new ResourceDTO
{
LoginName = txtUserName.Text,
LoginPassword = EncryptedPassword,
FirstName = Firstname.Text,
LastName = Lastname.Text,
Email = Email.Text
};
// Insert User into table
List <ResourceDTO> ExistingUser = new List <ResourceDTO>();
ExistingUser = con.GetAll("Resource", "LoginName", NewResource.LoginName, typeof(string)).Cast <ResourceDTO>().ToList();
if (ExistingUser.Count == 0)
{
NewResource = (ResourceDTO)(con.CreateObject(NewResource));
string strMessage = string.Format("Hej {0},\r\n\r\nDin bruger \"{1}\" er hermed oprettet i vores system! Vi håber du får set mange film hos os!\r\n\r\nMvh.\r\nTEC BioBooking!", NewResource.FirstName, NewResource.LoginName);
string strSubject = string.Format("Bruger {0} oprettet!", NewResource.LoginName);
Mailor mailor = new Mailor();
mailor.SendMail(NewResource.Email, strSubject, strMessage);
Response.Redirect("default.aspx");
}
else
{
lblMessage.Text = "Brugernavn er optaget - prøv igen.";
}
}
public async Task <IActionResult> Update(ResourceDTO update)
{
// for a real app it would be a good idea to configure model validation to remove long ifs like this
using var transaction = await this._transactionProvider.BeginTransaction();
var resource = await _service.GetResourceByProductName(update.Product.Name);
if (resource == null)
{
return(NotFound());
}
resource.Amount = update.Amount;
resource = await this._service.UpdateEntity(resource);
await transaction.CommitAsync();
return(Ok(new ResourceDTO
{
Amount = resource.Amount,
Product = await _productService.GetByName(update.Product.Name),
ActionHistories = resource.ActionHistories
}));
}
public bool SaveResource(ResourceDTO <string> resourceToSave)
{
try
{
var career = _careerRepository.GetMany(x => x.Name == resourceToSave.NameCareer);
var typeresource = _typeResourceRepository.GetMany(x => x.TypeName == resourceToSave.NameTypeResource);
if (career.FirstOrDefault() == null || !career.Any())
{
return(false);
}
if (typeresource.FirstOrDefault() == null || !typeresource.Any())
{
return(false);
}
var newResource = new Resource()
{
Author = resourceToSave.Author,
IdCareer = career.FirstOrDefault().IdCareer,
Description = resourceToSave.Description,
Link = resourceToSave.ResourceLink,
Title = resourceToSave.Title,
TypeResource = typeresource.FirstOrDefault().IdResource,
ResourceImage = null
};
_resourceRepository.Add(newResource);
_resourceRepository.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
public IActionResult CreateResource([FromBody] ResourceDTO resourceDTO)
{
if (resourceDTO == null)
{
return(BadRequest(ModelState));
}
if (_resource.ResourceExist(resourceDTO.Name))
{
ModelState.AddModelError("", "Resource already exist");
return(StatusCode(404, ModelState));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var resourceObj = _mapper.Map <Resource>(resourceDTO);
if (!_resource.CreateResource(resourceObj))
{
ModelState.AddModelError("", $"Something went wrong when saving the record{resourceObj.Name}");
return(StatusCode(500, ModelState));
}
return(CreatedAtRoute("GetResource", new { rid = resourceObj.RID }, resourceObj));
}
public async Task <IActionResult> EditResource(int resourceId)
{
var requestUrl = $"{BaseUrl}{apiUriResources}/GetResourceDetails?resourceId={resourceId}";
ResourceDTO resource = new ResourceDTO();
PopulateDropdownDTO populateDropdownDTO = new PopulateDropdownDTO();
populateDropdownDTO = await StaticDataHandler.PopulateResourceDropdown(BaseUrl);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(requestUrl);
HttpResponseMessage result = await client.GetAsync(requestUrl);
if (result.StatusCode == HttpStatusCode.OK)
{
resource = await result.Content.ReadAsAsync <ResourceDTO>();
}
else
{
resource.OutputHandler = await result.Content.ReadAsAsync <OutputHandler>();
}
resource.ResourceCategories = populateDropdownDTO.ResourceCategories;
resource.ResourceTypes = populateDropdownDTO.ResourceTypes;
};
resource.ResourceCategories = populateDropdownDTO.ResourceCategories;
resource.ResourceTypes = populateDropdownDTO.ResourceTypes;
resource.OldImageUrl = resource.ImageUrl;
return(View(resource));
}
public async Task <OutputResponse> Add(ResourceDTO resource)
{
var isFound = await _context.Resources.AnyAsync(x => x.ResourceName.ToLower() == resource.ResourceName.ToLower());
if (isFound)
{
return(new OutputResponse
{
IsErrorOccured = true,
Message = "Resource name already exist, duplicates not allowed"
});
}
var mappedResource = new AutoMapperHelper <ResourceDTO, Resources>().MapToObject(resource);
mappedResource.RowAction = "I";
mappedResource.DateCreated = DateTime.UtcNow.AddHours(2);
await _context.Resources.AddAsync(mappedResource);
await _context.SaveChangesAsync();
return(new OutputResponse
{
IsErrorOccured = false,
Message = MessageHelper.AddNewSuccess
});
}
public async Task <IHttpActionResult> PutResource(Guid id, ResourceDTO resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != resource.Id)
{
return(BadRequest());
}
var rawResource = ResourceFromResourceDTO(resource);
db.Entry(rawResource).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResourceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public ActionResult UpdateResource([FromBody] ResourceDTO resourceToUpdateDTO)
{
var resourceToUpdate = new Resource(resourceToUpdateDTO);
resourceService.Update(resourceToUpdate);
return(Ok());
}
public ActionResult <Resource> AddNewResource([FromBody] ResourceDTO newResourceDTO)
{
var resourceToAdd = new Resource(newResourceDTO);
var newResource = resourceService.Add(resourceToAdd);
return(Ok(newResource));
}
public RoutineInstanceBuilder AddParameter(String name, String sharedResourceId)
{
ResourceDTO sharedResource = new ResourceDTO();
sharedResource.Id = sharedResourceId;
inParams.Add(name, sharedResource);
return(this);
}
public RoutineInstanceBuilder AddParameter(String name, String dataTypeId, TBase value)
{
ResourceDTO resource = new ResourceDTO();
resource.DataTypeId = dataTypeId;
resource.Data = Serialize(value);
inParams.Add(name, resource);
return(this);
}
public static System.Collections.IEnumerable GetResources(int caseID, int providerID)
{
var resources = new List <ResourceDTO>
{
ResourceDTO.GetDefaultResource()
};
return(resources);
}
public List <NewsDTO> GetNews(ResourceDTO resource,
Expression <Func <News, bool> > newsWhere = null)
=> realm.Realm
.Find <Resource>(resource.Name)
.News
.Where(newsWhere ?? (_ => true))
.AsEnumerable()
.Select(mapper.Map <NewsDTO>)
.ToList();
public static IResource DTOToResource(ResourceDTO dto)
{
IRay ray = new Ray(dto.ID, new Point(dto.CenterX, dto.CenterY), dto.Angle);
IRenderable renderable = new Renderable(resourceBorderColor, resourceColor,
resourceLineThickness, resourceWidth, resourceHight, resourceVertices);
IShape shape = new Shape(dto.ID, ray, renderable, new RenderStrategy());
return(new Resource(dto.ID, shape, dto.Value));
}
public IActionResult Add([FromBody] ResourceDTO resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_rService.AddResource(resource, User.Identity.Name);
return(Ok());
}
public async Task <IActionResult> Update([FromBody] ResourceDTO resource)
{
var outputHandler = await _service.Update(resource);
if (outputHandler.IsErrorOccured)
{
return(BadRequest(outputHandler.Message));
}
return(Ok(outputHandler.Message));
}
private ResourceDTO ResourceDTOFromResource(Resource resource)
{
var dto = new ResourceDTO()
{
Id = resource.Id,
GatewayId = resource.GatewayId,
Name = resource.Name,
Uri = resource.Uri
};
return(dto);
}
public ResourceDTO Get(int resourceId)
{
var resource = Database.Resources.Get(resourceId);
var result = new ResourceDTO
{
Id = resource.Id,
Name = resource.Name,
Measure = resource.Measure,
};
return(result);
}
public async Task Update(ResourceDTO resourceDto)
{
var resource = new Resource
{
Id = resourceDto.Id,
Name = resourceDto.Name,
Measure = resourceDto.Measure
};
Database.Resources.Update(resource);
await Database.SaveAsync();
}
private Resource ResourceFromResourceDTO(ResourceDTO dto)
{
var resource = new Resource()
{
Id = dto.Id,
Name = dto.Name,
GatewayId = dto.GatewayId,
Uri = dto.Uri,
};
return(resource);
}
public static Resource MapToModel(ResourceDTO resourceDto)
{
Resource resource = new Resource();
resource.Id = resourceDto.Id;
resource.Author = resourceDto.Author;
resource.Description = resourceDto.Description;
resource.Image = resourceDto.Image;
resource.Name = resourceDto.Name;
resource.Type = resourceDto.Type;
resource.Url = resourceDto.Url;
return(resource);
}
public static ResourceDTO MapToDTO(Resource resource)
{
ResourceDTO resourceDTO = new ResourceDTO();
resourceDTO.Id = resource.Id;
resourceDTO.Author = resource.Author;
resourceDTO.Description = resource.Description;
resourceDTO.Image = resource.Image;
resourceDTO.Name = resource.Name;
resourceDTO.Type = resource.Type;
resourceDTO.Url = resource.Url;
return(resourceDTO);
}
public async Task <IActionResult> EditResource(ResourceDTO resource)
{
var output = await _service.EditResource(resource);
if (output.IsErrorOccured == true)
{
return(BadRequest(output));
}
else
{
return(Ok(output));
}
}
public async Task <IActionResult> AddResource()
{
PopulateDropdownDTO populateDropdownDTO = new PopulateDropdownDTO();
populateDropdownDTO = await StaticDataHandler.PopulateResourceDropdown(BaseUrl);
var resourceDTO = new ResourceDTO
{
ResourceCategories = populateDropdownDTO.ResourceCategories,
ResourceTypes = populateDropdownDTO.ResourceTypes
};
return(View(resourceDTO));
}
public ActionResult <ApiResponse <List <ResourceDTO> > > GetResources()
{
List <Resource> resources = this.repository.GetAll();
List <ResourceDTO> resesDTO = new List <ResourceDTO>();
foreach (Resource res in resources)
{
ResourceDTO resDTO = ResourceMapper.MapToDTO(res);
resesDTO.Add(resDTO);
}
return(new ApiResponse <List <ResourceDTO> >
{
Data = resesDTO
});
}
public IHttpActionResult CreateResource(ResourceDTO resourceDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var resource = Mapper.Map <ResourceDTO, Resource>(resourceDto);
_context.Resource.Add(resource);
_context.SaveChanges();
resourceDto.Id = resource.Id;
return(Created(new Uri(Request.RequestUri + "/" + resource.Id), resourceDto)); // by REST convention we should return uri of new data
}
// PUT: api/Hotel/5
public async Task <IHttpActionResult> Put(ResourceModel resource)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var resourceDTO = new ResourceDTO
{
Name = resource.Name,
Measure = resource.Measure
};
await ResourceService.Update(resourceDTO);
return(Ok());
}
public void DeleteResource(ResourceDTO resource, string currentUser)
{
Resource dbResource = new Resource()
{
Id = resource.Id,
Title = resource.Title,
Author = resource.Author,
Link = resource.Link,
ImageUrl = resource.ImageUrl,
DateCreated = DateTime.Now,
LastUpdated = DateTime.Now,
UserId = _uRepo.GetUser(currentUser).First().Id
};
_rRepo.Delete(dbResource, resource.Id);
}
public bool AddResource(ResourceDTO resource)
{
/*foreach(var resCost in resource.ResourcesCost)
* {
* ResourceCost resCostm = Mapper.Map<ResourceCost>(resCost);
* Database.ResourceCosts.Create(resCostm);
* Cost cost = Mapper.Map<Cost>(resCost.Cost);
* Database.Costs.Create(cost);
* Database.Save();
* }*/
Resource res = Mapper.Map <Resource>(resource);
Database.Resources.Create(res);
Database.Save();
return(true);
}
