public static RequestResult GetCopyFormModel(string abnormalReasonId)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var abnormalReason = context.AbnormalReasons.Include("Solutions").First(x => x.AbnormalReasonId == new Guid(abnormalReasonId));
var model = new CreateFormModel()
{
OrganizationId = abnormalReason.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(abnormalReason.OrganizationId),
Types = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = Resources.Resource.Create + "...",
Value = Define.New
}
},
SolutionModels = abnormalReason.Solutions.Select(x => new SolutionModel
{
SolutionId = x.SolutionId.ToString(),
Type = x.Type,
SId = x.SId,
Name = x.Name,
}).OrderBy(x => x.Type).ThenBy(x => x.SId).ToList(),
FormInput = new FormInput()
{
Type = abnormalReason.Type
}
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(abnormalReason.OrganizationId, true);
model.Types.AddRange(context.AbnormalReasons.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.Type).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
model.Types.First(x => x.Value == abnormalReason.Type).Selected = true;
result.ReturnData(model);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public async Task <IActionResult> Post([FromBody] CreateFormModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var form = new Form {
Name = model.FormName, FormJson = model.FormJson.ToString(), Title = model.FormTitle
};
var formId = await _tenantRepository.AddFormToProject(form, model.ProjectId, TenantId);
var user = await _userService.GetCurrentUserAsync(TenantId);
await _tenantRepository.AddUserToForm(user.Id, formId, TenantId, Role.SuperAdministrator);
return(Ok(new { id = formId, form_title = model.FormTitle }));
}
catch (Exception ex)
{
return(BadRequest(new { ex.Message }));
}
}
public async Task <IActionResult> Index(CreateFormModel formModel)
{
Console.WriteLine("Create Index..." + formModel.Project);
Console.WriteLine("Create Index...File: " + formModel.SessionFile.Name);
Console.WriteLine("Create Index...Length: " + formModel.SessionFile.Length);
var projectFilesResponse = await StartUpload(formModel.Project, formModel.SessionFile.FileName);
var awsStrResponse = await UploadToAWS(projectFilesResponse, formModel.SessionFile.OpenReadStream());
Console.WriteLine("AWS Response: " + awsStrResponse);
var confirmResponse = await ConfirmCheckin(formModel.Project, projectFilesResponse.Id);
Console.WriteLine("Confirm Status Code: " + confirmResponse);
var createSessionResponse = await CreateSession(formModel.Session);
Console.WriteLine("Create Session Response: " + createSessionResponse.Id);
var checkoutResponse = await CheckoutToSession(formModel.Project, projectFilesResponse.Id, createSessionResponse.Id);
var model = new CreateModel
{
SessionName = formModel.Session,
SessionID = createSessionResponse.Id,
ProjectID = formModel.Project,
FileSessionID = checkoutResponse.Id,
FileProjectID = projectFilesResponse.Id
};
return(View(model));
}
public static RequestResult Create(CreateFormModel createFormModel)
{
RequestResult result = new RequestResult();
try
{
if (createFormModel.FormInput.Type == Define.Other || createFormModel.FormInput.Type == Define.New)
{
result.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.Unsupported, Resources.Resource.AbnormalReasonType));
}
else
{
using (CFContext context = new CFContext())
{
var exists = context.AbnormalReasons.FirstOrDefault(x => x.OrganizationId == new Guid(createFormModel.OrganizationId) && x.Type == createFormModel.FormInput.Type && x.ARId == createFormModel.FormInput.ARId);
if (exists == null)
{
Guid abnormalReasonId = Guid.NewGuid();
context.AbnormalReasons.Add(new CF.Models.Maintenance.AbnormalReason()
{
AbnormalReasonId = abnormalReasonId,
OrganizationId = new Guid(createFormModel.OrganizationId),
Type = createFormModel.FormInput.Type,
ARId = createFormModel.FormInput.ARId,
Name = createFormModel.FormInput.Name,
LastModifyTime = DateTime.Now,
Solutions = createFormModel.SolutionModels.Select(x => new CF.Models.Maintenance.Solution()
{
SolutionId = new Guid(x.SolutionId),
SId = x.SId,
Name = x.Name,
Type = x.Type,
OrganizationId = new Guid(createFormModel.OrganizationId)
}).ToList(),
});
context.SaveChanges();
result.ReturnData(abnormalReasonId, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.AbnormalReason, Resources.Resource.Success));
}
else
{
result.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.ARId, Resources.Resource.Exists));
}
}
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public ActionResult Create(CreateFormModel createFormModel)
{
RequestResult requestResult = new RequestResult();
try
{
var model = Session["OrganizationCreateFormModel"] as CreateFormModel;
model.FormInput = createFormModel.FormInput;
requestResult = OrganizationDataAccessor.Create(model);
if (requestResult.IsSuccess)
{
HttpRuntime.Cache.Remove("Organizations");
Session.Remove("OrganizationFormAction");
Session.Remove("OrganizationCreateFormModel");
var account = Session["Account"] as Account;
account.OrganizationPermissions = OrganizationDataAccessor.GetOrganizationPermissions(account.OrganizationId);
Session["Account"] = account;
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(Content(JsonConvert.SerializeObject(requestResult)));
}
public ActionResult Create(CreateFormModel createFormModel)
{
RequestResult result = new RequestResult();
try
{
var model = Session["CheckItemCreateFormModel"] as CreateFormModel;
model.FormInput = createFormModel.FormInput;
result = CheckItemDataAccessor.Create(model);
if (result.IsSuccess)
{
Session.Remove("CheckItemFormAction");
Session.Remove("CheckItemCreateFormModel");
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(Content(JsonConvert.SerializeObject(result)));
}
public static object Create(CreateFormModel createFormModel)
{
RequestResult result = new RequestResult();
try
{
if (createFormModel.FormInput.EquipmentType == Define.New)
{
result.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.Unsupported, Resources.Resource.EquipmentType));
}
else
{
using (CFContext context = new CFContext())
{
var exists = context.ESpecifications.FirstOrDefault(x => x.OrganizationId == new Guid(createFormModel.OrganizationId) && x.EquipmentType == createFormModel.FormInput.EquipmentType && x.Name == createFormModel.FormInput.Name);
if (exists == null)
{
Guid equipmentSpecificationId = Guid.NewGuid();
context.ESpecifications.Add(new CF.Models.Maintenance.ESpecification()
{
ESpecificationId = equipmentSpecificationId,
OrganizationId = new Guid(createFormModel.OrganizationId),
EquipmentType = createFormModel.FormInput.EquipmentType,
Name = createFormModel.FormInput.Name
});
context.ESOptions.AddRange(createFormModel.FormInput.EquipmentSpecificationOptionModels.Select(x => new CF.Models.Maintenance.ESOption
{
ESOptionId = Guid.NewGuid(),
ESpecificationId = equipmentSpecificationId,
Name = x.Name,
Seq = x.Seq
}).ToList());
context.SaveChanges();
result.ReturnData(equipmentSpecificationId, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.EquipmentSpecification, Resources.Resource.Success));
}
else
{
result.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.EquipmentSpecificationName, Resources.Resource.Exists));
}
}
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public static RequestResult GetCopyFormModel(string equipmentSpecificationId)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var spec = context.ESpecifications.First(x => x.ESpecificationId == new Guid(equipmentSpecificationId));
var model = new CreateFormModel()
{
OrganizationId = spec.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(spec.OrganizationId),
EquipmentTypeSelectItems = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = string.Format("{0}...", Resources.Resource.Create),
Value = Define.New
}
},
FormInput = new FormInput()
{
EquipmentType = spec.EquipmentType
},
EquipmentSpecificationOptionModels = context.ESOptions.Where(x => x.ESpecificationId == spec.ESpecificationId).Select(x => new EquipmentSpecificationOptionModel
{
Name = x.Name,
Seq = x.Seq
}).OrderBy(x => x.Seq).ToList()
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(spec.OrganizationId, true);
model.EquipmentTypeSelectItems.AddRange(context.ESpecifications.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.EquipmentType).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
model.EquipmentTypeSelectItems.First(x => x.Value == spec.EquipmentType).Selected = true;
result.ReturnData(model);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public IActionResult Create()
{
var customPSModel = new CreateFormModel
{
Categories = db.Categories.ToList(),
Suppliers = db.Suppliers.ToList()
};
return(View("New", customPSModel));
}
public static RequestResult GetCreateFormModel(string organizationId, string solutionType)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var model = new CreateFormModel()
{
OrganizationId = organizationId,
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(new Guid(organizationId)),
SolutionTypes = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = Resources.Resource.Create + "...",
Value = Define.New
}
},
FormInput = new FormInput()
{
Type = solutionType
}
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(new Guid(organizationId), true);
model.SolutionTypes.AddRange(context.Solutions.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.Type).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
if (!string.IsNullOrEmpty(solutionType) && model.SolutionTypes.Any(x => x.Value == solutionType))
{
model.SolutionTypes.First(x => x.Value == solutionType).Selected = true;
}
result.ReturnData(model);
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return(result);
}
public ActionResult Create(string orgnaizationId)
{
Session["ControlPointFormAction"] = Define.EnumFormAction.Create;
Session["ControlPointCreateFormModel"] = new CreateFormModel()
{
OrganizationId = orgnaizationId,
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(new Guid(orgnaizationId))
};
return(PartialView("_Create", Session["ControlPointCreateFormModel"]));
}
public ActionResult Create(CreateFormModel createFormModel)
{
RequestResult result = PersonDataAccessor.Create(createFormModel);
if (result.IsSuccess)
{
HttpRuntime.Cache.Remove("Users");
}
return(Content(JsonConvert.SerializeObject(result)));
}
public async Task <IActionResult> Create(CreateFormModel model)
{
var cardId = new CardId(model.CardId);
var userId = new UserId(model.UserId);
var name = new CardName(model.Name);
var command = new CreateCard(cardId, userId, name);
await _lifetimeService.CreateAsync(command);
return(Ok());
}
public IActionResult Create([FromBody] CreateFormModel model)
{
var form = new Form()
{
FormSchema = model.FormSchema,
Name = model.FormName,
Url = model.FormName.GetFriendlyUrl(),
Key = Guid.NewGuid()
};
if (formService.Add(form))
{
return(Ok(form));
}
return(BadRequest());
}
public static RequestResult Create(CreateFormModel model)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var exists = context.Roles.FirstOrDefault(r => r.RoleId == model.FormInput.RoleId);
if (exists == null)
{
var pIds = model.People.Select(p => p.PId);
context.Roles.Add(new CF.Models.Role()
{
RoleId = model.FormInput.RoleId,
Name = model.FormInput.Name,
People = context.People.Where(p => pIds.Contains(p.LoginId)).ToList(),
WebPermissionWebFunctions = model.FormInput.WebPermissionFunctionList.Select(x => new CF.Models.RolePermissionFunction
{
RoleId = model.FormInput.RoleId,
WebPermissionId = x.WebPermissionId,
WebFunctionId = x.WebFunctionId
}).ToList()
});
context.SaveChanges();
requestResult.ReturnSuccessMessage(string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.Role, Resources.Resource.Success));
}
else
{
requestResult.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.RoleId, Resources.Resource.Exists));
}
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(requestResult);
}
public ActionResult Create(CreateFormModel createFormModel)
{
RequestResult requestResult = new RequestResult();
try
{
var model = Session["RoleCreateFormModel"] as CreateFormModel;
model.FormInput = createFormModel.FormInput;
requestResult = RoleDataAccessor.Create(model);
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(Content(JsonConvert.SerializeObject(requestResult)));
}
public ActionResult Create(string parentOrganizationId)
{
try
{
if (parentOrganizationId == "00000000-0000-0000-0000-000000000000")
{
Session["OrganizationCreateFormModel"] = new CreateFormModel()
{
AncestorOrganizationId = "00000000-0000-0000-0000-000000000000",
ParentId = "00000000-0000-0000-0000-000000000000",
ParentOrganizationFullName = "*"
};
}
else
{
var parentOrganization = OrganizationDataAccessor.GetOrganization(new Guid(parentOrganizationId));
Session["OrganizationCreateFormModel"] = new CreateFormModel()
{
AncestorOrganizationId = parentOrganization.AncestorOrganizationId.ToString(),
ParentId = parentOrganization.OrganizationId.ToString(),
ParentOrganizationFullName = parentOrganization.FullName
};
}
Session["OrganizationFormAction"] = Define.EnumFormAction.Create;
return(PartialView("_Create", Session["OrganizationCreateFormModel"]));
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
return(PartialView("_Error", err));
}
}
public ActionResult Create(CreateFormModel createFormModel, string pageStates)
{
RequestResult requestResult = new RequestResult();
try
{
var model = Session["MaterialCreateFormModel"] as CreateFormModel;
var pageStateList = JsonConvert.DeserializeObject <List <string> >(pageStates);
requestResult = MaterialDataAccessor.SavePageState(model.MaterialSpecificationModels, pageStateList);
if (requestResult.IsSuccess)
{
model.MaterialSpecificationModels = requestResult.Data as List <MaterialSpecificationModel>;
model.FormInput = createFormModel.FormInput;
requestResult = MaterialDataAccessor.Create(model);
if (requestResult.IsSuccess)
{
Session.Remove("MaterialFormAction");
Session.Remove("MaterialCreateFormModel");
}
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
}
return(Content(JsonConvert.SerializeObject(requestResult)));
}
public static RequestResult GetCopyFormModel(Guid materialId)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var material = context.Materials.First(x => x.MaterialId == materialId);
var createFormModel = new CreateFormModel()
{
OrganizationId = material.OrganizationId.ToString(),
ParentOrganizationFullName = OrganizationDataAccessor.GetOrganizationFullName(material.OrganizationId),
MaterialTypeSelectItems = new List <SelectListItem>()
{
Define.DefaultSelectListItem(Resources.Resource.Select),
new SelectListItem()
{
Text = Resources.Resource.Create + "...",
Value = Define.New
}
},
FormInput = new FormInput()
{
MaterialType = material.MaterialType
},
MaterialSpecificationModels = (from x in context.MaterialSpecificationOptions
join s in context.MSpecifications
on x.MSpecificationId equals s.MSpecificationId
where x.MaterialId == material.MaterialId
select new MaterialSpecificationModel
{
MaterialSpecificationId = s.MSpecificationId.ToString(),
Name = s.Name,
MaterialSpecificationOptionId = x.MSOptionId.ToString(),
Value = x.Value,
Seq = x.Seq,
MaterialSpecificationOptionModels = context.MSOptions.Where(o => o.MSpecificationId == s.MSpecificationId).Select(o => new MaterialSpecificationOptionModel
{
MaterialSpecificationId = o.MSpecificationId.ToString(),
Seq = o.Seq,
Name = o.Name,
MaterialSpecificationOptionId = o.MSOptionId.ToString()
}).OrderBy(o => o.Seq).ToList()
}).OrderBy(x => x.Seq).ToList()
};
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(material.OrganizationId, true);
createFormModel.MaterialTypeSelectItems.AddRange(context.Materials.Where(x => upStreamOrganizationIds.Contains(x.OrganizationId)).Select(x => x.MaterialType).Distinct().OrderBy(x => x).Select(x => new SelectListItem
{
Value = x,
Text = x
}).ToList());
createFormModel.MaterialTypeSelectItems.First(x => x.Value == material.MaterialType).Selected = true;
requestResult.ReturnData(createFormModel);
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
}
return(requestResult);
}
public static RequestResult Create(CreateFormModel createFormModel)
{
RequestResult result = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var exists = context.Checkpoints.FirstOrDefault(x => x.OrganizationId == new Guid(createFormModel.OrganizationId) && x.CId == createFormModel.FormInput.CId);
if (exists == null)
{
if (!string.IsNullOrEmpty(createFormModel.FormInput.TagId) && context.Checkpoints.Any(x => x.TagId == createFormModel.FormInput.TagId))
{
var checkpoint = context.Checkpoints.First(x => x.TagId == createFormModel.FormInput.TagId);
var organization = OrganizationDataAccessor.GetOrganization(checkpoint.OrganizationId);
result.ReturnFailedMessage(string.Format("{0} {1} {2} {3} {4}", Resources.Resource.TagId, createFormModel.FormInput.TagId, Resources.Resource.Exists, organization.Name, checkpoint.Name));
}
else
{
Guid checkpointId = Guid.NewGuid();
context.Checkpoints.Add(new CF.Models.Maintenance.Checkpoint()
{
CheckpointId = checkpointId,
OrganizationId = new Guid(createFormModel.OrganizationId),
CId = createFormModel.FormInput.CId,
Name = createFormModel.FormInput.Name,
IsFeelItemDefaultNormal = createFormModel.FormInput.IsFeelItemDefaultNormal,
TagId = createFormModel.FormInput.TagId,
Remark = createFormModel.FormInput.Remark,
CheckItems = createFormModel.CheckItemModels.Select(x => new CF.Models.Maintenance.CheckItem()
{
CheckItemId = new Guid(x.CheckItemId),
IsInherit = x.IsInherit,
LowerLimit = x.LowerLimit,
LowerAlertLimit = x.LowerAlertLimit,
UpperAlertLimit = x.UpperAlertLimit,
UpperLimit = x.UpperLimit,
AccumulationBase = x.AccumulationBase,
Unit = x.Unit,
Remark = x.Remark
}).ToList(),
LastModifyTime = DateTime.Now
});
context.SaveChanges();
result.ReturnData(checkpointId, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.Checkpoint, Resources.Resource.Success));
}
}
else
{
result.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.CId, Resources.Resource.Exists));
}
}
}
catch (Exception ex)
{
var err = new Error(MethodBase.GetCurrentMethod(), ex);
Logger.Log(err);
result.ReturnError(err);
}
return result;
}
public static RequestResult Create(CreateFormModel createFormModel)
{
RequestResult requestResult = new RequestResult();
try
{
if (createFormModel.FormInput.MaterialType == Define.New)
{
requestResult.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.Unsupported, Resources.Resource.MaterialType));
}
else
{
using (CFContext context = new CFContext())
{
var exists = context.Materials.FirstOrDefault(x => x.OrganizationId == new Guid(createFormModel.OrganizationId) && x.MaterialType == createFormModel.FormInput.MaterialType && x.MId == createFormModel.FormInput.MId);
if (exists == null)
{
Guid materialId = Guid.NewGuid();
context.Materials.Add(new CF.Models.Maintenance.Material()
{
MaterialId = materialId,
OrganizationId = new Guid(createFormModel.OrganizationId),
MaterialType = createFormModel.FormInput.MaterialType,
MId = createFormModel.FormInput.MId,
Name = createFormModel.FormInput.MaterialName,
Quantity = createFormModel.FormInput.Quantity ?? 0
});
context.MaterialSpecificationOptions.AddRange(createFormModel.MaterialSpecificationModels.Select(x => new CF.Models.Maintenance.MaterialSpecificationOption
{
MaterialId = materialId,
MSpecificationId = new Guid(x.MaterialSpecificationId),
MSOptionId = new Guid(x.MaterialSpecificationOptionId),
Value = x.Value,
Seq = x.Seq
}).ToList());
context.SaveChanges();
requestResult.ReturnData(materialId, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.Material, Resources.Resource.Success));
}
else
{
requestResult.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.MId, Resources.Resource.Exists));
}
}
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
}
return(requestResult);
}
public static RequestResult Create(CreateFormModel createFormModel)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var exists = context.Organizations.FirstOrDefault(x => x.ParentId.ToString() == createFormModel.ParentId && x.OId == createFormModel.FormInput.OId);
if (exists == null)
{
//OrganizationId为Guid自动生成，此处先形成organization对象，为了下面获取数据库中自动生成的OrganizationId。
//var organization = new CF.Models.Organization()
//{
// ParentId = createFormModel.ParentId,
// OId = createFormModel.FormInput.OId,
// Name = createFormModel.FormInput.Name,
//};
//context.Organizations.Add(organization);
var organization = new CF.Models.Organization()
{
OrganizationId = Guid.NewGuid(),
ParentId = new Guid(createFormModel.ParentId),
OId = createFormModel.FormInput.OId,
Name = createFormModel.FormInput.Name
};
context.Organizations.Add(organization);
if (!string.IsNullOrEmpty(createFormModel.FormInput.Managers))
{
context.OrganizationManagers.AddRange(createFormModel.FormInput.Managers.Split(',').ToList().Select(om => new OrganizationManager()
{
OrganizationId = organization.OrganizationId,
ManagerId = om
}));
}
context.EditableOrganizations.AddRange(createFormModel.EditableOrganizations.Where(x => x.CanDelete).Select(x => new EditableOrganization
{
OrganizationId = organization.OrganizationId,
EditableOrganizationId = x.OrganizationId
}).ToList());
context.QueryableOrganizations.AddRange(createFormModel.QueryableOrganizations.Select(x => new QueryableOrganization
{
OrganizationId = organization.OrganizationId,
QueryableOrganizationId = x.OrganizationId
}).ToList());
context.SaveChanges();
requestResult.ReturnData(organization.OrganizationId, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.Organization, Resources.Resource.Success));
}
else
{
requestResult.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.OrganizationId, Resources.Resource.Exists));
}
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(requestResult);
}
public ActionResult Create(CreateFormModel createFormModel)
{
return(Content(JsonConvert.SerializeObject(SolutionDataAccessor.Create(createFormModel))));
}
/// <returns>Success operation</returns>
/// <exception cref="SwaggerException">A server side error occurred.</exception>
public void _api_AddTableEntity_post(CreateFormModel data)
{
System.Threading.Tasks.Task.Run(async() => await _api_AddTableEntity_postAsync(data, System.Threading.CancellationToken.None)).GetAwaiter().GetResult();
}
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <returns>Success operation</returns>
/// <exception cref="SwaggerException">A server side error occurred.</exception>
public async System.Threading.Tasks.Task _api_AddTableEntity_postAsync(CreateFormModel data, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
var urlBuilder_ = new System.Text.StringBuilder();
urlBuilder_.Append(BaseUrl).Append("/api/AddTableEntity");
var client_ = new System.Net.Http.HttpClient();
try
{
using (var request_ = new System.Net.Http.HttpRequestMessage())
{
var content_ = new System.Net.Http.StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(data, _settings.Value));
content_.Headers.ContentType.MediaType = "application/json";
request_.Content = content_;
request_.Method = new System.Net.Http.HttpMethod("POST");
PrepareRequest(client_, request_, urlBuilder_);
var url_ = urlBuilder_.ToString();
request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
PrepareRequest(client_, request_, url_);
var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
try
{
var headers_ = System.Linq.Enumerable.ToDictionary(response_.Headers, h_ => h_.Key, h_ => h_.Value);
foreach (var item_ in response_.Content.Headers)
{
headers_[item_.Key] = item_.Value;
}
ProcessResponse(client_, response_);
var status_ = ((int)response_.StatusCode).ToString();
if (status_ == "204")
{
return;
}
else
if (status_ != "200" && status_ != "204")
{
var responseData_ = await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
throw new SwaggerException("The HTTP status code of the response was not expected (" + (int)response_.StatusCode + ").", status_, responseData_, headers_, null);
}
}
finally
{
if (response_ != null)
{
response_.Dispose();
}
}
}
}
finally
{
if (client_ != null)
{
client_.Dispose();
}
}
}
public static RequestResult Create(CreateFormModel model)
{
RequestResult requestResult = new RequestResult();
try
{
using (CFContext context = new CFContext())
{
var exists = context.People.FirstOrDefault(p => p.LoginId == model.FormInput.Id);
if (exists == null)
{
bool exceedsLimit = false;
var upStreamOrganizationIds = OrganizationDataAccessor.GetUpStreamOrganizationIds(new Guid(model.OrganizationId), true);
PopulationLimit populationLimit = null;
foreach (var item in Config.PopulationLimits)
{
if (upStreamOrganizationIds.Contains(item.OrganizationId))
{
populationLimit = item;
break;
}
}
if (populationLimit != null)
{
var organization = OrganizationDataAccessor.GetOrganization(populationLimit.OrganizationId);
var downStreamOrganizations = OrganizationDataAccessor.GetDownStreamOrganizations(populationLimit.OrganizationId, true);
var people = context.People.Where(p => downStreamOrganizations.Contains(p.OrganizationId)).ToList();
if (people.Count + 1 > populationLimit.NumberOfPeople)
{
exceedsLimit = true;
requestResult.ReturnFailedMessage(string.Format(Resources.Resource.ExceedsPopulationLimit, organization.Name, populationLimit.NumberOfPeople));
}
else
{
if (model.FormInput.IsMobilePerson && people.Count(x => x.IsMobilePerson) + 1 > populationLimit.NumberOfMobilePeople)
{
exceedsLimit = true;
requestResult.ReturnFailedMessage(string.Format(Resources.Resource.ExceedsMobilePopulationLimit, organization.Name, populationLimit.NumberOfMobilePeople));
}
}
}
if (!exceedsLimit)
{
var roles = context.Roles.Where(r => model.FormInput.RoleIdsString.Contains(r.RoleId)).ToList();
context.People.Add(new CF.Models.Person()
{
OrganizationId = new Guid(model.OrganizationId),
LoginId = model.FormInput.Id,
Name = model.FormInput.Name,
Password = model.FormInput.Id,
Title = model.FormInput.Title,
Email = model.FormInput.EMail,
IsMobilePerson = model.FormInput.IsMobilePerson,
LastModifyTime = DateTime.Now,
Roles = roles
});
context.SaveChanges();
requestResult.ReturnData(model.FormInput.Id, string.Format("{0} {1} {2}", Resources.Resource.Create, Resources.Resource.Person, Resources.Resource.Success));
}
}
else
{
requestResult.ReturnFailedMessage(string.Format("{0} {1}", Resources.Resource.PId, Resources.Resource.Exists));
}
}
}
catch (Exception e)
{
var error = new Error(MethodBase.GetCurrentMethod(), e);
Logger.Log(error);
requestResult.ReturnError(error);
//throw;
}
return(requestResult);
}
