public async Task <BaseResponseModelPost> Create(AppErrorModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
AppError appError = new AppError
{
Deleted = false,
Exception = request.Exception ?? UNKNOWN,
Function = request.Function ?? UNKNOWN,
InnerException = request.InnerException ?? UNKNOWN,
Message = request.Message ?? UNKNOWN,
Module = request.Module ?? UNKNOWN,
Solved = false,
Time = request.Time ?? DateTime.Now,
AppInfo = request.AppInfo ?? UNKNOWN
};
await Database.AppError.AddAsync(appError);
await Database.SaveChangesAsync();
response.Id = appError.Id;
response.Message = "App error was successfully created!";
return(response);
}
public async Task <ActionResult> Registration(RegistrationViewModel model)
{
Task task = GetLanguages(model);
if (ModelState.IsValid)
{
if (model.Password == model.ConfirmPassword)
{
BaseResponseModelPost result = await _crudService.Create(model, null, UserService.UserEntity);
AddMessageToModel(model, result.Message, !result.Success);
if (result.Success)
{
AddViewModelToTempData(model);
return(RedirectToAction("Login"));
}
}
else
{
AddMessageToModel(model, "Password and confirmed password are not equal!");
}
}
await Task.WhenAll(task);
return(View(model));
}
public async Task <BaseResponseModelPost> Create(AffectedFieldModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
AffectedField affectedField = new AffectedField
{
Name = request.Name,
Description = request.Description
};
await Database.AffectedField.AddAsync(affectedField);
await Database.SaveChangesAsync();
response.Id = affectedField.Id;
response.Message = "Affected field was successfully created!";
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public async Task <BaseResponseModelPost> Create(MetricTypeModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
MetricType metricType = new MetricType
{
Name = request.Name,
Description = request.Description
};
await Database.MetricType.AddAsync(metricType);
await Database.SaveChangesAsync();
response.Id = metricType.Id;
response.Message = "Metric type was successfully created!";
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public async Task <BaseResponseModelPost> Create(AspiceVersionModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
AspiceVersion aspiceVersion = new AspiceVersion
{
ReleaseDate = request.ReleaseDate,
Description = request.Description,
VersionNumber = request.VersionNumber
};
await Database.AspiceVersion.AddAsync(aspiceVersion);
await Database.SaveChangesAsync();
response.Id = aspiceVersion.Id;
response.Message = "Automotive SPICE version was successfully created!";
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public async Task <BaseResponseModelPost> Create(UserModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
if (ValidateEmail(request.Email, response) && ValidatePassword(request.Password, response))
{
request.Username = request.Username ?? request.Email;
if (await CheckUsername(request.Username, response) && await CheckLanguage(request.LanguageId, response))
{
User user = new User
{
Email = request.Email,
FirstName = request.Firstname,
LanguageId = request.LanguageId,
LastName = request.Lastname,
LdapUrl = request.LdapUrl,
Salt = PasswordHelper.GeneratePassword(10),
Username = request.Username,
UseLdaplogin = request.UseLdaplogin,
CompanyId = request.CompanyId
};
if (!string.IsNullOrEmpty(request.Company))
{
user.Company = new Company {
Name = request.Company
};
}
user.Password = PasswordHelper.EncodePassword(request.Password, user.Salt);
if (user.CompanyId.HasValue || user.Company != null)
{
user.UserRole = await GetUserRole(MainController.RoleAdmin);
}
else
{
user.UserRole = await GetUserRole(MainController.RoleUser);
}
await Database.User.AddAsync(user);
await Database.SaveChangesAsync();
response.Id = user.Id;
response.Message = string.IsNullOrEmpty(request.Company) ? "User was successfully created!" : "User and company were successfully created!";
}
}
}
else
{
response.Success = false;
response.Message = "Some of the required user properties is not present!";
}
return(response);
}
public async Task <BaseResponseModelPost> Create(MetricModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
if (await CheckAspiceProcess(request.AspiceProcessId, response))
{
if (await CheckMetricType(request.MetricTypeId, response))
{
if (await CheckAffectedField(request.AffectedFieldId, response))
{
if (await CheckMetricIdentificator(request.Identificator, response))
{
if (CheckMetricColumns(request.Columns, response))
{
Metric metric = new Metric
{
Name = request.Name,
Description = request.Description,
Identificator = request.Identificator,
RequirementGroup = request.RequirementGroup,
AspiceProcessId = request.AspiceProcessId,
AffectedFieldId = request.AffectedFieldId,
MetricTypeId = request.MetricTypeId,
Public = CurrentUser.CompanyId.HasValue ? request.Public : true,
CompanyId = CurrentUser.CompanyId
};
for (int i = 0; i < request.Columns.Count; i++)
{
await CreateMetricColumn(metric, request.Columns[i]);
}
await Database.Metric.AddAsync(metric);
await Database.SaveChangesAsync();
response.Id = metric.Id;
response.Message = "Metric was successfully created!";
}
}
}
}
}
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public async Task <BaseResponseModelPost> Create <T>(T model, string jwt, string entity)
{
BaseResponseModelPost result = new BaseResponseModelPost();
await PostToAPI(SerializeObjectToJSON(model), async (httpResult) =>
{
result = JsonConvert.DeserializeObject <BaseResponseModelPost>(await httpResult.Content.ReadAsStringAsync());
}, entity, jwt : jwt);
return(result);
}
public async Task <BaseResponseModelPost> FindUserIdByUsername(string username, string jwt)
{
BaseResponseModelPost result = new BaseResponseModelPost();
await GetToAPI(GetParametersList(GetParameter("username", username)), async httpResult =>
{
result = JsonConvert.DeserializeObject <BaseResponseModelPost>(await httpResult.Content.ReadAsStringAsync());
}, jwt : jwt);
return(result);
}
public async Task <BaseResponseModelPost> GetByUsername(string username)
{
BaseResponseModelPost response = new BaseResponseModelPost();
User user = await Database.User.AsNoTracking().FirstOrDefaultAsync(a => a.Username == username);
if (user == null)
{
response.Success = false;
response.Message = "Unknown username!";
}
else
{
response.Id = user.Id;
}
return(response);
}
public async Task <BaseResponseModelPost> Create(ProjectMetricModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
if (await CheckMetric(request, response) && await CheckProject(request.ProjectId, response) && TestURL(request.DataUrl, response))
{
ProjectMetric projectMetric = new ProjectMetric
{
MetricId = request.MetricId,
ProjectId = request.ProjectId,
CreateDate = DateTime.Now,
LastUpdateDate = DateTime.Now,
DataUrl = request.DataUrl,
DataUsername = request.DataUsername,
DataPassword = PasswordHelper.Base64Encode(request.DataPassword),
Warning = request.Warning,
MinimalWarningValue = request.Warning ? request.MinimalWarningValue ?? 0 : default(decimal?)
};
await Database.ProjectMetric.AddAsync(projectMetric);
await Database.SaveChangesAsync();
response.Id = projectMetric.Id;
response.Message = "Project metric was successfully created!";
}
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
public async Task <BaseResponseModelPost> Create(ProjectModel request)
{
BaseResponseModelPost response = new BaseResponseModelPost();
if (request.Validate())
{
Project project = new Project
{
Name = request.Name,
Description = request.Description,
CreateDate = DateTime.Now
};
await Database.Project.AddAsync(project);
ProjectUser userProject = new ProjectUser
{
JoinDate = DateTime.Now,
Project = project,
UserId = CurrentUser.Id
};
await Database.ProjectUser.AddAsync(userProject);
await Database.SaveChangesAsync();
response.Id = project.Id;
response.Message = "Project was successfully created!";
}
else
{
response.Success = false;
response.Message = "Some of the required properties is not present!";
}
return(response);
}
