public IActionResult Create(ProjectsVm ProjectsVm)
{
logger.LogDebug($"Project.Create [post] is called");
try
{
if (ProjectsVm.Projects == null)
{
throw new ArgumentException();
}
if (ModelState.IsValid)
{
ProjectDto projectDto = ConvertToProjectDto.Convert(ProjectsVm.Projects);
ProjectService.Create(projectDto);
}
else
{
return(View(ProjectsVm));
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(View("Error"));
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult Create(ProjectTaskFilledVm projectTaskFilledVm)
{
logger.LogDebug($"ProjectTask.Create [post] is called");
try
{
if (projectTaskFilledVm == null)
{
throw new ArgumentException("Variable shuld not be null", nameof(projectTaskFilledVm));
}
if (ModelState.IsValid)
{
ProjectTaskDto projectTaskDto = ConvertToProjectTaskDto.Convert(projectTaskFilledVm.ProjectTasks);
ProjectTaskService.Create(projectTaskDto);
}
else
{
return(View(projectTaskFilledVm));
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(View("Error"));
}
return(RedirectToAction(nameof(Index)));
}
public void Create(EmployeeDto item)
{
logger.LogDebug(this.GetType() + ".Create is called");
Employee Employee = EmployeeConverter.Convert(item);
EmployeeRepository.Create(Employee);
}
public ProjectDto Get(int id)
{
logger.LogDebug(this.GetType() + ".Get is called");
Project Project = ProjectRepository.GetSingle(id);
return(ProjectDtoConverter.Convert(Project));
}
public IList <ProjectTaskDto> GetAll()
{
IList <ProjectTask> ProjectTasks = ProjectTaskRepository.GetAll();
IList <ProjectTaskDto> ProjectTasksDto = ProjectTaskDtoConverter.Convert(ProjectTasks);
return(ProjectTasksDto);
}
public void Create(ProjectDto item)
{
logger.LogDebug(this.GetType() + ".Create is called");
Project Project = ProjectConverter.Convert(item);
ProjectRepository.Create(Project);
}
public IActionResult Create(EmployeeVm employee)
{
logger.LogDebug($"Employee.Create [post] is called");
try
{
if (employee == null)
{
throw new ArgumentException("Variable shuld not be null", nameof(employee));
}
if (ModelState.IsValid)
{
EmployeeService.Create(ConvertToEmployeeDto.Convert(employee));
}
else
{
return(View(employee));
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(View("Error"));
}
return(RedirectToAction(nameof(Index)));
}
public IActionResult Index()
{
logger.LogDebug($"Project.Index is called");
IList <ProjectVm> Projects = ConvertToProjectVm.Convert(ProjectService.GetAll());
return(View(Projects));
}
public IActionResult Index()
{
logger.LogDebug($"ProjectTask.Index is called");
IList <ProjectTaskVm> ProjectTasksVm = ConvertToProjectTaskVm.Convert(ProjectTaskService.GetAll());
FillProjectTasksVm(ProjectTasksVm);
return(View(ProjectTasksVm));
}
public EmployeeDto Get(int id)
{
logger.LogDebug(this.GetType() + ".Get is called");
Employee Employee = EmployeeRepository.GetSingle(id);
EmployeeDto EmployeeDto = EmployeeDtoConverter.Convert(Employee);
return(EmployeeDto);
}
public IActionResult Index()
{
logger.LogDebug($"Employee.Index is called");
IList <EmployeeDto> EmployeesDto = EmployeeService.GetAll();
List <EmployeeVm> EmployeesVm = new List <EmployeeVm>();
foreach (var item in EmployeesDto)
{
EmployeesVm.Add(ConvertToEmployeeVm.Convert(item));
}
return(View(EmployeesVm));
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation(LogInfo.ServiceStarted, "Worker started at: {time}", DateTimeOffset.Now);
while (!stoppingToken.IsCancellationRequested)
{
var data = (await _parser.GetData(_settings.uri)).ToList();
var count = data.Count();
_logger.LogInformation(LogInfo.DataParsed, "Parser get {count} entries", count);
if (count > 0)
{
var processedData = data.AsParallel().Select(x => _converter.Convert(x)).ToList();
_logger.LogInformation(LogInfo.DataParsed, "Plaintext data converted to objects");
await _writer.WriteAll(processedData);
_logger.LogInformation(LogInfo.DataWritten, "Worker writed at: {time}", DateTimeOffset.Now);
}
else
{
_logger.LogCritical(LogInfo.Error, "No data parsed");
}
await Task.Delay(30 * 1000, stoppingToken);
}
_logger.LogInformation(LogInfo.ServiceStopped, "Worker stopped at: {time}", DateTimeOffset.Now);
}
internal static object[] Convert(string[] objects, ParameterInfo[] wantedTypes, IPlayer invoker, bool withOptional = false, string debug = "")
{
try
{
Wrapper.Server.Logger.Debug(debug + ": " + JsonConvert.SerializeObject(objects));
object[] arr = new object[wantedTypes.Length];
arr[0] = invoker;
for (int i = 1; i < wantedTypes.Length; i++)
{
ParameterInfo wantedType = wantedTypes[i];
if (withOptional && wantedType.IsOptional && (i - 1) >= objects.Length)
{
arr[i] = Type.Missing;
continue;
}
IConvert convert = FindConvert(wantedType.ParameterType);
if (convert != null)
{
arr[i] = convert.Convert(objects[i - 1], wantedType.ParameterType);
}
}
return(arr);
}
catch (Exception e)
{
Wrapper.Server.Logger.Error("An error occurred in converting process!", e);
return(null);
}
}
private async Task <Stats> LoadStats(Guid chapterId, Guid profileId, int pages)
{
var stats =
await _database.QueryStats(chapterId, profileId) ??
await _stats.Add(DbStats.Create(profileId, chapterId, pages));
return(_convertStats.Convert(stats));
}
public IActionResult Edit(int id)
{
logger.LogDebug($"Project.Edit [get] is called");
ProjectVm ProjectVm = ConvertToProjectVm.Convert(ProjectService.Get(id));
IList <ProjectTaskVm> ProjectTasksVm = ConvertToProjectTaskVm.Convert(ProjectTaskService.GetAllByProjectId(ProjectVm.Id));
ProjectsVm model = ComposeProjectVm(ProjectVm, ProjectTasksVm);
return(View("CreateOrEdit", model));
}
private static void Test(IConvert convert, ConvertType ctype)
{
A2 obj = new A2 {
Id = 1, Name = "A1"
};
A1 obj2 = convert.Convert <A2, A1>(obj);
Show(obj, obj2, ctype);
}
public async Task <Stats> Stats(Guid profileId, Guid chapterId)
{
var profile = await _profiles.Get(profileId, UserId);
var stats = await _database.QueryStats(chapterId, profile.Id);
stats.Validate();
return(_stats.Convert(stats));
}
public object ProcessRequest(byte[] requestBytes, IPAddress address, WebSocket socket)
{
var requestAsString = _toStringConverter.Convert(requestBytes);
try
{
var json = JObject.Parse(requestAsString);
var type = json["type"].ToString();
var payload = json["payload"].ToString();
switch (type)
{
case "clientOffer":
var clientOfferRequest = new ClientOfferRequest(address, socket, payload);
var clientOfferRequestHandler = _handlersFactory.Create(clientOfferRequest, clientOfferRequest.GetResponseType());
return(clientOfferRequestHandler.Handle(clientOfferRequest));
case "serverOffer":
var serverRequest = new ServerOfferRequest(address, socket, payload);
var serverRequestHandler = _handlersFactory.Create(serverRequest, serverRequest.GetResponseType());
return(serverRequestHandler.Handle(serverRequest));
case "answer":
var answerRequest = new AnswerRequest(address, socket, payload);
var answerRequestHandler = _handlersFactory.Create(answerRequest, answerRequest.GetResponseType());
return(answerRequestHandler.Handle(answerRequest));
case "new-ice":
var newICERequest = new NewICEAvailableRequest(address, socket, payload);
var newICERequestHandler = _handlersFactory.Create(newICERequest, newICERequest.GetResponseType());
return(newICERequestHandler.Handle(newICERequest));
case "txt":
default:
var txtRequest = new TxtRequest(address, socket, payload);
var txtRequestHandler = _handlersFactory.Create(txtRequest, txtRequest.GetResponseType());
return(txtRequestHandler.Handle(txtRequest));
}
}
catch (System.Exception ex)
{
return($@"An error {ex} occured.");
}
}
public void Encode(string sourceFile)
{
var sourceToken = _jsonFileProcessor.Load(sourceFile);
var gameToken = _gameConverter.Convert(sourceToken);
var relativeFile = DirectoryHelper.MakeRelative(SourcePath, sourceFile);
var gameFile = Path.GetFullPath(Path.Combine(GamePath, relativeFile));
gameFile = Path.ChangeExtension(gameFile, "rxdata");
DirectoryHelper.EnsureDirectoryExists(Path.GetDirectoryName(gameFile));
_rubyEncoder.Encode(gameToken, gameFile, EncoderOptions);
}
public void Decode(string gameFile)
{
var gameToken = _rubyEncoder.Decode(gameFile, DecoderOptions);
var sourceToken = _sourceConverter.Convert(gameToken);
var relativeFile = DirectoryHelper.MakeRelative(GamePath, gameFile);
var sourceFile = Path.GetFullPath(Path.Combine(SourcePath, relativeFile));
sourceFile = Path.ChangeExtension(sourceFile, "json");
DirectoryHelper.EnsureDirectoryExists(Path.GetDirectoryName(sourceFile));
_jsonFileProcessor.Save(sourceToken, sourceFile);
}
private void Run()
{
while (true)
{
var line = io.Read();
if (!string.IsNullOrWhiteSpace(line))
{
if (string.Equals(line, "STOP", StringComparison.InvariantCultureIgnoreCase))
{
return;
}
var result = converter.Convert(line);
io.Write(result);
}
}
}
private ActionResult processRequest(string textToParse, string fileName, IConvert converter)
{
if (textToParse != null)
{
Parser parser = new Parser();
Text text = parser.Parse(textToParse);
string result = converter.Convert(text);
byte[] fileBytes = Encoding.UTF8.GetBytes(result);
return(File(fileBytes, System.Net.Mime.MediaTypeNames.Application.Octet, fileName));
}
else
{
ModelState.AddModelError("text", "Please enter text");
return(View());
}
}
public async Task <Profile> Get(Guid profileId, string userId)
{
var profile = await _cache.GetOrAddAsync(profileId.ToString(),
async() => _converter.Convert(await _profiles.Get(profileId)));
if (profile == null)
{
throw new NotFoundException($"Profile for ID {profileId} not found.");
}
if (profile.UserId != userId)
{
throw new UnauthorizedException($"Access to Profile {profileId} denied.");
}
return(profile);
}
/// <summary>
/// Converts the given objects into it wanted types.
/// </summary>
/// <param name="objects">The given objects</param>
/// <param name="wantedTypes">The wanted types</param>
public static object[] Convert(string[] objects, Type[] wantedTypes)
{
object[] arr = new object[objects.Length];
for (int i = 0; i < objects.Length; i++)
{
Type wantedType = wantedTypes[i];
string obj = objects[i];
IConvert convert = FindConvert(wantedType);
if (convert != null)
{
try
{
arr[i + 1] = convert.Convert(obj, wantedType);
}
catch (Exception e)
{
Wrapper.Server.Logger.Error("An error occurred while converting " + obj + " to " + wantedType.FullName + "!", e);
}
}
}
return(arr);
}
/// <summary>
/// Converts between versions of the IFC schema, upwards or downwards.
/// </summary>
/// <param name="sourceObject">Ths source object (use IfcProject to capture everything), which must be of the sourceType indicated in the constructor.</param>
/// <returns>The new object that has been converted to the targetType indicated in the constructor.</typeparam></returns>
public object Convert(object sourceObject)
{
// copy over fields and trace dependencies
ObjectIDGenerator gen = new ObjectIDGenerator();
Dictionary <object, object> mapInstances = new Dictionary <object, object>(); // map from object from source schema to object in target schema
Dictionary <object, object> mapChanges = new Dictionary <object, object>(); // map from object from source schema to converted object in source schema
Queue <object> qRoot = new Queue <object>();
qRoot.Enqueue(sourceObject);
while (qRoot.Count > 0)
{
// process the queue
object o = qRoot.Dequeue();
object oReplacement = o;
// allocate target object
Type typeSource = o.GetType();
Type typeTarget = this.m_adapterTarget.GetType(typeSource.Name);
// heal any objects first (before transforming)
Type t = typeSource.BaseType;
while (t != typeof(object))
{
IConvert healer = null;
if (this.m_mapHealers.TryGetValue(t, out healer))
{
healer.Convert(o, t);
}
t = t.BaseType;
}
Type typeOverride = null;
if (this.m_mapTypes != null && this.m_mapTypes.TryGetValue(typeSource, out typeOverride))
{
typeTarget = typeOverride;
// pre-convert, such as for geometry (may or may not convert to within the same IFC version)
IConvert typeconverter = null;
if (this.m_mapConverters != null && this.m_mapConverters.TryGetValue(typeSource, out typeconverter))
{
oReplacement = typeconverter.Convert(o, typeTarget);
if (oReplacement != null)
{
mapChanges.Add(o, oReplacement);
typeSource = oReplacement.GetType();
typeTarget = this.m_adapterTarget.GetType(typeSource.Name);
}
}
else
{
typeTarget = this.m_adapterTarget.GetType(typeOverride.Name);
}
}
if (typeTarget == null || typeTarget.IsAbstract || oReplacement == null)
{
mapInstances.Add(o, null); // record null to void future conversion, report what didn't convert
}
else
{
object target = Activator.CreateInstance(typeTarget);
// map it immediately
mapInstances.Add(o, target);
bool firstTime;
long id = gen.GetId(o, out firstTime);
IList <PropertyInfo> fieldsDirect = this.m_adapterSource.GetDirectFields(oReplacement.GetType());
foreach (PropertyInfo field in fieldsDirect)
{
if (field != null && !field.PropertyType.IsValueType)
{
object inval = field.GetValue(oReplacement);
if (inval is IEnumerable)
{
IEnumerable list = (IEnumerable)inval;
foreach (object oival in list)
{
if (oival != null && !oival.GetType().IsValueType&& !(oival is string))
{
gen.GetId(oival, out firstTime);
if (firstTime)
{
qRoot.Enqueue(oival);
}
}
}
}
else if (inval is object)
{
if (inval != null && !inval.GetType().IsValueType&& !(inval is string))
{
gen.GetId(inval, out firstTime);
if (firstTime)
{
qRoot.Enqueue(inval);
}
}
}
}
}
// capture inverse fields -- don't use properties, as those will allocate superflously
IList <PropertyInfo> fields = this.m_adapterSource.GetInverseFields(oReplacement.GetType());
foreach (PropertyInfo field in fields)
{
object inval = field.GetValue(oReplacement);
if (inval is IEnumerable)
{
IEnumerable list = (IEnumerable)inval;
foreach (object oival in list)
{
gen.GetId(oival, out firstTime);
if (firstTime)
{
qRoot.Enqueue(oival);
}
}
}
else if (inval is object)
{
gen.GetId(inval, out firstTime);
if (firstTime)
{
qRoot.Enqueue(inval);
}
}
}
}
}
// populate fields
foreach (object o in mapInstances.Keys)
{
object target = mapInstances[o];
if (target != null)
{
object source = null;
if (!mapChanges.TryGetValue(o, out source))
{
source = o;
}
IList <PropertyInfo> fieldsSource = this.m_adapterSource.GetDirectFields(source.GetType());
IList <PropertyInfo> fieldsTarget = this.m_adapterTarget.GetDirectFields(target.GetType());
for (int iField = 0; iField < fieldsSource.Count && iField < fieldsTarget.Count; iField++)
{
PropertyInfo fieldSource = fieldsSource[iField];
PropertyInfo fieldTarget = fieldsTarget[iField];
if (fieldSource != null && fieldTarget != null) // null if derived
{
object valueSource = fieldSource.GetValue(source);
if (valueSource != null)
{
object valueTarget = ConvertValue(valueSource, fieldTarget.PropertyType, mapInstances);
if (valueTarget != null)
{
fieldTarget.SetValue(target, valueTarget);
this.m_adapterTarget.UpdateInverseReferences(target, fieldTarget, valueTarget);
}
}
else if (fieldTarget.PropertyType.IsEnum && !fieldTarget.PropertyType.IsGenericType) // if non-nullable enum, must populate
{
object valueTarget = null;
// use NOTDEFINED if provided, otherwise pick first constant
// (e.g. IfcSpatialStructureElement.ElementCompositionType is required in IFC2x3, optional in IFC4, and there's no NOTDEFINED value) --> ELEMENT should be used in such case
FieldInfo[] fieldConstants = fieldTarget.PropertyType.GetFields(BindingFlags.Public | BindingFlags.Static);
foreach (FieldInfo fieldConst in fieldConstants)
{
Enum enumvalue = (Enum)fieldConst.GetValue(null);
int intvalue = (int)System.Convert.ChangeType(enumvalue, enumvalue.GetTypeCode());
if (intvalue == 0)
{
valueTarget = enumvalue;
break;
}
}
valueTarget = fieldConstants[0].GetValue(null);
fieldTarget.SetValue(target, valueTarget);
}
}
}
// populate any required fields on target object
//for (int iField = 0; iField < fieldsTarget.Count; iField++)
//{
//}
}
}
return(mapInstances[sourceObject]);
}
public void Create(ProjectTaskDto item)
{
ProjectTask ProjectTask = ProjectTaskConverter.Convert(item);
ProjectTaskRepository.Create(ProjectTask);
}
