public void update(FieldDTO entity)
{
SqlSingleton.getInstance().ExecQuery("update field set " +
" value='" + entity.value + "'" +
" where idContact=" + entity.idContact + "" +
" and name='" + entity.name + "';");
}
/// <summary>
/// method to get fields for request
/// </summary>
/// <param name="requestID">takes requestid as input</param>
/// <returns>returns list of fields</returns>
public List <FieldDTO> GetFields(string requestID)
{
string callerMethodName = string.Empty;
try
{
//Get Caller Method name from CallerInformation class
callerMethodName = CallerInformation.TrackCallerMethodName();
SynchDAL synchDAL = new SynchDAL();
//calling data access layer method
List <FieldEntity> fieldsentitylist = synchDAL.GetFields(requestID);
List <FieldDTO> fileds = new List <FieldDTO>();
//loop through fields list entity to convert to fields dto
foreach (FieldEntity field in fieldsentitylist)
{
FieldDTO fielddto = DataProvider.ResponseObjectMapper <FieldDTO, FieldEntity>(field);
fileds.Add(fielddto);
}
return(fileds);
}
catch (DataAccessException DALexception)
{
throw DALexception;
}
catch (Exception exception)
{
InsightLogger.Exception(exception.Message, exception, callerMethodName);
//LoggerHelper.WriteToLog(exception + " - Error in BL while getting fields per request : "
//+ exception.ToString(), CoreConstants.Priority.High, CoreConstants.Category.Error);
throw new BusinessLogicException();
}
}
/// <summary>
/// Get or sets value of configuration field with the given key stored in current activity storage
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
protected string this[string key]
{
get
{
CheckCurrentActivityStorageAvailability();
var crate = Storage.FirstCrateOrDefault <FieldDescriptionsCM>(x => x.Label == ConfigurationValuesCrateLabel);
return(crate?.Content.Fields.FirstOrDefault(x => x.Key == key)?.Value);
}
set
{
CheckCurrentActivityStorageAvailability();
var crate = Storage.FirstCrateOrDefault <FieldDescriptionsCM>(x => x.Label == ConfigurationValuesCrateLabel);
if (crate == null)
{
crate = Crate <FieldDescriptionsCM> .FromContent(ConfigurationValuesCrateLabel, new FieldDescriptionsCM(), AvailabilityType.Configuration);
Storage.Add(crate);
}
var field = crate.Content.Fields.FirstOrDefault(x => x.Key == key);
if (field == null)
{
field = new FieldDTO(key, AvailabilityType.Configuration);
crate.Content.Fields.Add(field);
}
field.Value = value;
Storage.ReplaceByLabel(crate);
}
}
public async Task <FieldDTO> Edit(FieldDTO dto)
{
var field = dto.MapTo <TField>();
await fieldRepository.Edit(field, Session);
return(field.MapTo <FieldDTO>());
}
public void Add(FieldDTO entity)
{
SqlSingleton.getInstance().ExecQuery("insert into field (name,value,idContact) values (" +
"'" + entity.name + "'," +
"'" + entity.value + "'," +
"'" + entity.idContact + "');");
}
public async Task <ActionResult <FieldDTO> > Put(int fieldId, [FromBody] FieldDTO dto)
{
try
{
var oldField = await UnitOfWork.GetFieldByIdAsync(fieldId);
if (oldField == null)
{
return(NotFound($"Could not find field with moniker of {fieldId}"));
}
Mapper.Map(dto, oldField);
if (await UnitOfWork.SaveChangesAsync())
{
return(Mapper.Map <FieldDTO>(oldField));
}
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}
public static void UpdateField(FieldDTO dto)
{
using (var conn = new SqlConnection(ConfigurationManager.ConnectionStrings["Local"].ConnectionString))
{
conn.Execute("UPDATE Field SET Name = @Name, AllowFreeText = @AllowFreeText, IsRequired = @IsRequired, IsMultiSelect = @IsMultiSelect WHERE FieldId = @FieldId",
new { dto.FieldId, dto.Name, dto.AllowFreeText, dto.IsMultiSelect, dto.IsRequired });
}
}
public IHttpActionResult UpdateField([FromBody]FieldDTO fieldDTO)
{
if (fieldDTO == null) {
return BadRequest("FieldDTO cannot be null");
}
fieldSvc.UpdateField(fieldDTO);
return Ok();
}
public static Field ConvertToEntity(this FieldDTO dto)
{
return(new Field {
Id = dto.Id,
Description = dto.Description,
Name = dto.Name,
Type = dto.Type
});
}
public async Task <IHttpActionResult> Update(Guid fieldId, [FromBody] FieldDTO fieldDTO)
{
if (fieldDTO.FieldId != fieldId)
{
return(BadRequest("Id mismatch"));
}
return(await Save(fieldDTO));
}
public FieldRepoTests()
{
_context = new EFContext();
_repository = new FieldRepository(_context);
_context.PurgeData();
_fieldDto = new FieldDTO {
Id = 8, Name = "hello", Description = "something", Type = FieldType.BOOL
};
}
public async Task <IHttpActionResult> Insert([FromBody] FieldDTO fieldDTO)
{
if (fieldDTO.FieldId != Guid.Empty)
{
return(BadRequest("Invalid FieldId"));
}
return(await Save(fieldDTO));
}
public Field MapToField(FieldDTO fieldDTO)
{
return(new Field()
{
Name = fieldDTO.Name,
EngName = fieldDTO.EngName,
ShortName = fieldDTO.ShortName,
Specializations = fieldDTO.Specializations?.Select(spec => MapToSpecialization(spec)).ToList()
});
}
public FieldConfigurator AddField(FieldDTO field)
{
field = field.Clone();
field.SourceCrateLabel = _label;
field.SourceCrateManifest = _manifestType;
field.SourceActivityId = _sourceActivityId.ToString();
field.Availability = _availabilityType;
_fields.Add(field);
return(this);
}
public async Task <ActionResult <FieldDTO> > PostField(FieldDTO fieldDto)
{
var field = await fieldService.Edit(fieldDto);
if (field == null)
{
return(BadRequest());
}
return(Ok(field));
}
private static List <ListItem> FillSalesforceSupportedObjects()
{
var fields =
new FieldDTO[]
{
new FieldDTO("Account")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Contact")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Lead")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Opportunity")
{
Availability = AvailabilityType.Configuration
},
//new FieldDTO("Forecast") {Availability = AvailabilityType.Configuration},
new FieldDTO("Contract")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Order")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Case")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Solution")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Product2")
{
Availability = AvailabilityType.Configuration
},
new FieldDTO("Document")
{
Availability = AvailabilityType.Configuration
}
//new FieldDTO("File") {Availability = AvailabilityType.Configuration}
};
return(fields.Select(x => new ListItem()
{
Key = x.Name, Value = x.Name
}).ToList());
}
public FieldDTO update(FieldDTO entity)
{
var field = uow.GetRepository <Field>().Get(x => x.Id == entity.Id);
if (field != null)
{
field = Mapper.Map <Field>(entity);
uow.SaveChanges();
return(Mapper.Map <FieldDTO>(field));
}
return(null);
}
public FieldDTO add(FieldDTO entity)
{
if (entity.FormId > 0 && !string.IsNullOrEmpty(entity.Name) && !string.IsNullOrEmpty(entity.DataType))
{
Field field = Mapper.Map <Field>(entity);
uow.GetRepository <Field>().Add(field);
uow.SaveChanges();
return(Mapper.Map <FieldDTO>(field));
}
return(null);
}
public ActionResult EditField(EditFieldViewModel model)
{
var dto = new FieldDTO();
dto.FieldId = model.FieldId;
dto.Name = model.Name;
dto.AllowFreeText = model.AllowFreeText;
dto.IsMultiSelect = model.IsMultiSelect;
dto.IsRequired = model.IsRequired;
DataAccess.UpdateField(dto);
return(RedirectToAction("EditActivity", "Settings", new { activityId = DataAccess.GetField(model.FieldId).ActivityId }));
}
public StandardPayloadDataCM TransformStandardTableDataToStandardPayloadData(string curObjectType, StandardTableDataCM tableDataMS)
{
var payloadDataMS = new StandardPayloadDataCM()
{
PayloadObjects = new List <PayloadObjectDTO>(),
ObjectType = curObjectType,
};
int staringRow;
TableRowDTO columnHeadersRowDTO = null;
if (tableDataMS.FirstRowHeaders)
{
staringRow = 1;
columnHeadersRowDTO = tableDataMS.Table[0];
}
else
{
staringRow = 0;
}
// Rows containing column names
for (int i = staringRow; i < tableDataMS.Table.Count; ++i) // Since first row is headers; hence i starts from 1
{
try
{
var tableRowDTO = tableDataMS.Table[i];
var fields = new List <FieldDTO>();
int colNumber = (tableDataMS.FirstRowHeaders) ? columnHeadersRowDTO.Row.Count : tableRowDTO.Row.Count;
for (int j = 0; j < colNumber; ++j)
{
var tableCellDTO = tableRowDTO.Row[j];
var listFieldDTO = new FieldDTO()
{
Key = (tableDataMS.FirstRowHeaders) ? columnHeadersRowDTO.Row[j].Cell.Value : tableCellDTO.Cell.Key,
Value = tableCellDTO.Cell.Value
};
fields.Add(listFieldDTO);
}
payloadDataMS.PayloadObjects.Add(new PayloadObjectDTO()
{
PayloadObject = fields
});
}
catch (Exception)
{
//Avoid general failure of the process if there is an error processing individual records in the table
}
}
return(payloadDataMS);
}
private static Field ConvertFieldDTOToField(FieldDTO fieldDTO)
{
return(new Field {
Field_Id = fieldDTO.Field_Id,
Name = fieldDTO.Name,
Branch_Id = fieldDTO.Branch_Id,
Cost = fieldDTO.Cost,
Length = fieldDTO.Length,
Material = fieldDTO.Material,
Number = fieldDTO.Number,
Width = fieldDTO.Width
});
}
public IHttpActionResult CreateField([FromBody] FieldDTO field)
{
field f = new field {
address = field.Address, description = field.Description, enabled = true, latitude = (float)field.latitude, longitude = (float)field.longitude, name = field.Name, sport = (int)field.sport
};
using (var context = new escorcenterdbEntities())
{
context.fields.Add(f);
context.SaveChanges();
}
return(Ok(f));
}
public IHttpActionResult UpdateField([FromBody] FieldDTO _field)
{
field fieldMap = AutoMapper.Mapper.Map <FieldDTO, field>(_field);
field f;
using (var context = new escorcenterdbEntities())
{
f = (from r in context.fields where r.Id == fieldMap.Id select r).FirstOrDefault();
f = fieldMap;
context.SaveChanges();
}
return(Ok(f));
}
protected static object GetValue(ICrateStorage payloadStorage, FieldDTO fieldToMatch)
{
if (payloadStorage == null)
{
throw new ArgumentNullException(nameof(payloadStorage));
}
if (fieldToMatch == null)
{
throw new ArgumentNullException(nameof(fieldToMatch));
}
if (string.IsNullOrWhiteSpace(fieldToMatch.Name))
{
return(null);
}
IEnumerable <Crate> filteredCrates = payloadStorage;
if (!string.IsNullOrWhiteSpace(fieldToMatch.SourceActivityId))
{
filteredCrates = filteredCrates.Where(x => x.SourceActivityId == fieldToMatch.SourceActivityId);
}
if (!string.IsNullOrEmpty(fieldToMatch.SourceCrateLabel))
{
filteredCrates = filteredCrates.Where(x => x.Label == fieldToMatch.SourceCrateLabel);
}
if (fieldToMatch.SourceCrateManifest != CrateManifestType.Any && fieldToMatch.SourceCrateManifest != CrateManifestType.Unknown)
{
filteredCrates = filteredCrates.Where(x => x.ManifestType.Equals(fieldToMatch.SourceCrateManifest));
}
//iterate through found crates and search for the field with the specified key
foreach (var crate in filteredCrates)
{
// skip system crates
if (crate.IsOfType <OperationalStateCM>() || crate.IsOfType <CrateDescriptionCM>() || crate.IsOfType <ValidationResultsCM>())
{
continue;
}
var foundValue = GetValue(crate, fieldToMatch.Name);
if (foundValue != null)
{
return(foundValue);
}
}
return(null);
}
public void UpdateField(FieldDTO fieldDTO)
{
try {
Field field = ConvertFieldDTOToField(fieldDTO);
using (RampUpProjectEntities dbContext = new RampUpProjectEntities(rampConnectionString)) {
dbContext.Fields.Attach(field);
dbContext.Entry(field).State = System.Data.Entity.EntityState.Modified;
dbContext.SaveChanges();
}
} catch (Exception) {
throw;
}
}
public FieldDTO AddField(FieldDTO fieldDTO)
{
try {
Field field = ConvertFieldDTOToField(fieldDTO);
using (RampUpProjectEntities dbContext = new RampUpProjectEntities(rampConnectionString)) {
dbContext.Fields.Add(field);
dbContext.SaveChanges();
}
return(ConvertFieldToFieldDTO(field));
} catch (Exception) {
throw;
}
}
public async Task <IActionResult> CreateField([FromBody] FieldDTO field)
{
if (!ModelState.IsValid || field.Id != 0)
{
return(BadRequest(ModelState));
}
var create = await _fieldLogic.Create(field);
field.Id = create;
return(Ok(create));
//return CreatedAtAction("GetField", create);
//return CreatedAtAction("GetField", new {create}, create);
}
public async Task <IActionResult> UpdateField([FromBody] FieldDTO field, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var update = await _fieldLogic.Update(field, id);
if (update)
{
return(NoContent());
}
return(NotFound());
}
private List <FieldDTO> createFinalPath(List <Field> targetPath)
{
List <FieldDTO> finalPath = new List <FieldDTO>();
foreach (var field in targetPath)
{
var protofield = new FieldDTO()
{
X_Cord = field.X_Cord,
Y_Cord = field.Y_Cord,
Status = field.Status
};
finalPath.Add(protofield);
}
return(finalPath);
}
public async Task <ActionResult <FieldDTO> > Post([FromBody] FieldDTO dto)
{
try
{
var location = LinkGenerator.GetPathByAction("Get", "Field", new { id = dto.FieldId });
if (string.IsNullOrWhiteSpace(location))
{
return(BadRequest("Could not use current Id"));
}
Field field;
switch (dto.Sport)
{
case Sports.Tennis:
field = Mapper.Map <TennisCourt>(dto);
break;
case Sports.Paddle:
field = Mapper.Map <PaddleCourt>(dto);
break;
case Sports.Soccer:
field = Mapper.Map <SoccerField>(dto);
break;
default: field = null;
break;
}
await UnitOfWork.AddFieldAsync(field);
return(Created($"/api/field/{field.FieldId}", Mapper.Map <FieldDTO>(field)));
}
catch (Exception)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Database Failure"));
}
return(BadRequest());
}