/// <summary>
/// Get content update for current user from last login
/// </summary>
/// <returns></returns>
public ContentUpdateWidget GetContentUpdates()
{
if (WorkContext.CurrentUser != null && WorkContext.CurrentUser.LastTimeGettingUpdate.HasValue)
{
var logs = _subscriptionLogService.GetLogs(null, WorkContext.CurrentUser.LastTimeGettingUpdate.Value,
SubscriptionEnums.SubscriptionModule.Page);
var pageIds =
logs.Select(l => l.Parameters)
.ToList()
.Select(p => SerializeUtilities.Deserialize <SubscriptionPageParameterModel>(p).Id);
var pages = _pageService.Maps(_pageService.Fetch(p => pageIds.Contains(p.Id))).ToList();
var pageLogs = logs.GroupBy(l => l.Parameters).ToList().Select(l => new PageSubscriptionLogModel
{
Page =
pages.FirstOrDefault(
p => p.Id == SerializeUtilities.Deserialize <SubscriptionPageParameterModel>(l.Key).Id) ??
new PageModel(),
Logs = l.Select(i => new SubscriptionLogItem(i)).ToList()
}).ToList();
return(new ContentUpdateWidget
{
TotalChanges = pageLogs.Count,
TotalLogs = pageLogs.Sum(l => l.Logs.Count),
PageLogs = pageLogs
});
}
return(new ContentUpdateWidget());
}
private EmailQueue GetEmail(FormType type, string jsonData, string employeeEmail, string employeeName)
{
var email = new EmailQueue()
{
From = "",
FromName = "Hệ Thống",
To = employeeEmail,
ToName = employeeName,
Subject = "",
CreatedBy = "system",
Created = DateTime.Now,
RecordActive = true,
};
var data = new object();
string resourceName = string.Empty;
string templateFilePath = string.Empty;
switch (type)
{
case FormType.Admission:
email.Subject = "Đăng kí nhập học";
data = SerializeUtilities.Deserialize <AdmissionData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Admission.cshtml";
break;
case FormType.Advisory:
email.Subject = "Đăng kí tư vấn";
data = SerializeUtilities.Deserialize <AdvisoryData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Advisory.cshtml";
break;
case FormType.Alumni:
email.Subject = "Thông tin cựu sinh viên";
data = SerializeUtilities.Deserialize <AlumniData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Alumni.cshtml";
break;
case FormType.Contact:
email.Subject = "Liên hệ";
data = SerializeUtilities.Deserialize <ContactData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.Contact.cshtml";
break;
case FormType.Visit:
email.Subject = "Đăng kí tham quan";
data = SerializeUtilities.Deserialize <VisitSchoolData>(jsonData);
resourceName = "Kent.Business.Core.EmailTemplate.VisitSchool.cshtml";
break;
}
var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
string templateStr = reader.ReadToEnd();
email.Body = Engine.Razor.RunCompile(templateStr, "templateKey", null, data);
}
return(email);
}
public ActionResult AdvisoryListing(string keyword, bool?export)
{
var listing = _formServices.GetListForms(FormType.Advisory, keyword);
List <AdvisoryData> dataLst = listing
.Select(d =>
{
var data = SerializeUtilities.Deserialize <AdvisoryModel>(d.Data);
return(new AdvisoryData()
{
Name = data.Name,
Email = data.Email,
PhoneNumber = data.PhoneNumber,
DateCreated = d.DateSubmit.Value
});
}).ToList();
if (export.HasValue && export.Value)
{
var gv = new GridView();
gv.DataSource = dataLst;
gv.DataBind();
Response.ClearContent();
Response.Buffer = true;
Response.AddHeader("content-disposition", "attachment; filename=Danh sách tư vấn.xls");
Response.ContentType = "application/ms-excel";
Response.Charset = "";
StringWriter objStringWriter = new StringWriter();
HtmlTextWriter objHtmlTextWriter = new HtmlTextWriter(objStringWriter);
gv.RenderControl(objHtmlTextWriter);
Response.Output.Write(objStringWriter.ToString());
Response.Flush();
Response.End();
}
return(View(dataLst));
}
public void ConvertFloatToByteArray()
{
float f = 69.6969696f;
byte[] bytes = SerializeUtilities.ConvertFloatToByteArray(f);
Assert.AreEqual(f, SerializeUtilities.ConvertByteArrayToFloat(bytes));
}
public void Load()
{
Debug.Log(Path.Combine(UnityEngine.Application.persistentDataPath, FolderName));
for (int i = 0; i < windowSizes.Length; i++)
{
string fullPath = Path.Combine(UnityEngine.Application.persistentDataPath, FolderName, $"{FileName}_L{i}{Extension}");
if (File.Exists(fullPath))
{
string jsonString = File.ReadAllText(fullPath);
SerializableTransformList transformList = JsonUtility.FromJson <SerializableTransformList>(jsonString);
// first element is always the root transform (WindowSize_LX)
SerializeUtilities.DeserializeTransform(transformList.TransformList[0], windowSizes[i].transform);
Transform[] transforms = windowSizes[i].GetComponentsInChildren <Transform>();
int transformIndex = 1; // skip the first entry
for (int j = 0; j < transforms.Length; j++)
{
if (transforms[j].tag.Equals("StencilMask"))
{
SerializeUtilities.DeserializeTransform(transformList.TransformList[transformIndex], transforms[j]);
transformIndex++;
}
}
}
}
}
/// <summary>
/// Get page subscription email content
/// </summary>
/// <param name="emailModels"></param>
/// <param name="template"></param>
/// <param name="isAnythingChanged"></param>
/// <returns></returns>
private string GetPageSubscriptionEmailContent(List <SubscriptionEmailModel> emailModels,
SubscriptionTemplate template, ref bool isAnythingChanged)
{
var pageService = HostContainer.GetInstance <IPageService>();
var subscriptionTemplateService = HostContainer.GetInstance <ISubscriptionTemplateService>();
// Get a list of pageId in SubscriptionEmailModel
var pageIds =
emailModels.Select(l => SerializeUtilities.Deserialize <SubscriptionPageParameterModel>(l.Parameters).Id)
.ToList();
// Map that list of pageId to list of PageModel
var pages = pageService.Maps(pageService.Fetch(p => pageIds.Contains(p.Id))).ToList();
// Select a list of PageSubscriptionEmailModel from SubscriptionEmailModel and PageModel
var model = emailModels.Select(m => new PageSubscriptionEmailModel
{
SubscriptionId = m.SubscriptionId,
Page =
pages.FirstOrDefault(
p => p.Id == SerializeUtilities.Deserialize <SubscriptionPageParameterModel>(m.Parameters).Id) ??
new PageModel(),
Logs = m.Logs
}).ToList();
// Enable flag for sending email
if (model.Any(e => e.Logs.Any()))
{
isAnythingChanged = true;
}
return(subscriptionTemplateService.ParseSubscription(template.Module, model).Body);
}
/// <summary>
/// Save site setup
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveCompanySetupModel(CompanySetupModel model)
{
ResponseModel response;
var setting = _siteSettingRepository.FetchFirst(s => s.Name.Equals(SettingNames.CompanySetupSetting));
if (setting == null)
{
setting = new SiteSetting
{
Name = SettingNames.CompanySetupSetting,
Description = SettingNames.CompanySetupSetting,
Value = SerializeUtilities.Serialize(model),
SettingType = "system"
};
response = _siteSettingRepository.Insert(setting);
}
else
{
setting.Value = SerializeUtilities.Serialize(model);
response = _siteSettingRepository.Update(setting);
}
return(response);
}
public EmailLogDetailModel(EmailLog emailLog)
: this()
{
Id = emailLog.Id;
Priority = emailLog.Priority;
From = emailLog.From;
FromName = emailLog.FromName;
To = emailLog.To;
ToName = emailLog.ToName;
if (!string.IsNullOrEmpty(emailLog.CC))
{
CcList = emailLog.CC.Split(';').ToList();
}
if (!string.IsNullOrEmpty(emailLog.Bcc))
{
BccList = emailLog.Bcc.Split(';').ToList();
}
Subject = emailLog.Subject;
SentTries = emailLog.SentTries;
SentOn = emailLog.SentOn;
Body = emailLog.Body;
EmailAccountId = emailLog.EmailAccountId;
if (!string.IsNullOrEmpty(emailLog.Message))
{
Logs = SerializeUtilities.Deserialize <List <EmailSendingLog> >(emailLog.Message);
}
RecordOrder = emailLog.RecordOrder;
Created = emailLog.Created;
CreatedBy = emailLog.CreatedBy;
LastUpdate = emailLog.LastUpdate;
LastUpdateBy = emailLog.LastUpdateBy;
}
/// <summary>
/// Search notified contacts
/// </summary>
/// <param name="notificationId"></param>
/// <returns></returns>
private IQueryable <NotifiedContactModel> SearchNotifiedContacts(int notificationId)
{
var notification = FetchFirst(n => n.Id == notificationId);
return
(SerializeUtilities.Deserialize <List <NotifiedContactModel> >(notification.NotifiedContacts).AsQueryable());
}
/// <summary>
/// Save template
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveTemplateManageModel(WidgetTemplateManageModel model)
{
ResponseModel response;
var template = GetById(model.Id);
if (template != null)
{
var log = new WidgetTemplateLogManageModel(template);
template.Name = model.Name;
template.Widgets = SerializeUtilities.Serialize(model.Shortcuts);
template.Content = model.Content;
template.Style = model.Style;
template.Script = model.Script;
template.FullContent = GetFullTemplate(model);
response = Update(template);
if (response.Success)
{
_templateLogService.SaveTemplateLog(log);
}
return(response.SetMessage(response.Success
? T("WidgetTemplate_Message_UpdateSuccessfully")
: T("WidgetTemplate_Message_UpdateFailure")));
}
Mapper.CreateMap <WidgetTemplateManageModel, WidgetTemplate>();
template = Mapper.Map <WidgetTemplateManageModel, WidgetTemplate>(model);
template.FullContent = GetFullTemplate(model);
response = CreateTemplate(template);
return(response.SetMessage(response.Success
? T("WidgetTemplate_Message_CreateSuccessfully")
: T("WidgetTemplate_Message_CreateFailure")));
}
/// <summary>
/// Save form default component field
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public ResponseModel SaveFormDefaultComponentField(FormDefaultComponentFieldManageModel model)
{
ResponseModel response;
var formDefaultComponentField = GetById(model.Id);
if (formDefaultComponentField != null)
{
formDefaultComponentField.FormDefaultComponentId = model.FormDefaultComponentId;
formDefaultComponentField.Name = model.Name;
formDefaultComponentField.Attributes = SerializeUtilities.Serialize(model.Attributes);
formDefaultComponentField.RecordOrder = model.RecordOrder;
response = Update(formDefaultComponentField);
return(response.SetMessage(response.Success
? T("FormDefaultComponentField_Message_UpdateSuccessfully")
: T("FormDefaultComponentField_Message_UpdateFailure")));
}
formDefaultComponentField = new FormDefaultComponentField
{
FormDefaultComponentId = model.FormDefaultComponentId,
Name = model.Name,
Attributes = SerializeUtilities.Serialize(model.Attributes),
RecordOrder = model.RecordOrder
};
response = Insert(formDefaultComponentField);
return(response.SetMessage(response.Success
? T("FormDefaultComponentField_Message_CreateSuccessfully")
: T("FormDefaultComponentField_Message_CreateFailure")));
}
public void BufferInt16IntoByteArrayTest()
{
Int16 testVal = 0x3456;
byte[] testBuff = new byte[10];
for (int i = 0; i < testBuff.Length;)
{
i = SerializeUtilities.BufferInt16InToByteArray(testVal,
testBuff, i, Endianness.big_endian);
}
for (int i = 0; i < testBuff.Length;)
{
Assert.AreEqual((byte)((testVal >> 8) & 0xFF), testBuff[i++]);
Assert.AreEqual((byte)(testVal & 0xFF), testBuff[i++]);
}
for (int i = 0; i < testBuff.Length;)
{
i = SerializeUtilities.BufferInt16InToByteArray(testVal,
testBuff, i, Endianness.little_endian);
}
for (int i = 0; i < testBuff.Length;)
{
Assert.AreEqual((byte)(testVal & 0xFF), testBuff[i++]);
Assert.AreEqual((byte)((testVal >> 8) & 0xFF), testBuff[i++]);
}
}
public void Save()
{
for (int i = 0; i < windowSizes.Length; i++)
{
WindowTransformLists[i].TransformList.Add(SerializeUtilities.SerializeTransform(windowSizes[i].transform));
Transform[] transforms = windowSizes[i].GetComponentsInChildren <Transform>();
foreach (Transform t in transforms)
{
if (t.tag.Equals("StencilMask"))
{
WindowTransformLists[i].TransformList.Add(SerializeUtilities.SerializeTransform(t));
}
}
string jsonString = JsonUtility.ToJson(WindowTransformLists[i], true);
string fullPath = Path.Combine(UnityEngine.Application.persistentDataPath, FolderName, $"{FileName}_L{i}{Extension}");
if (File.Exists(fullPath))
{
File.WriteAllText(fullPath, jsonString);
Debug.Log($"Saved transforms to {fullPath}");
}
else
{
Directory.CreateDirectory(Path.Combine(UnityEngine.Application.persistentDataPath, FolderName));
File.Create(fullPath);
Debug.Log($"Savedata file was created: {fullPath}");
}
}
}
/// <summary>
/// Get subscription by module and parameters
/// </summary>
/// <param name="module"></param>
/// <param name="email"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public SubscriptionModel GetSubscription(SubscriptionEnums.SubscriptionModule module, string email,
string parameters)
{
if (parameters != null)
{
var data = Fetch(s => s.Active && s.Module == module && s.Email.Equals(email)).ToList();
if (data.Any())
{
var subscriptions = data.Select(s => new SubscriptionModel(s));
switch (module)
{
case SubscriptionEnums.SubscriptionModule.Page:
var param = SerializeUtilities.Deserialize <SubscriptionPageParameterModel>(parameters);
var subscription =
subscriptions.FirstOrDefault(
s => ((SubscriptionPageParameterModel)s.Parameters).Id == param.Id);
if (subscription != null)
{
return(subscription);
}
break;
}
}
}
return(null);
}
/// <summary>
/// Get access token
/// </summary>
/// <param name="clientId"></param>
/// <param name="secretKey"></param>
/// <param name="code"></param>
/// <param name="callbackUrl"></param>
/// <param name="expiredDate"></param>
/// <returns></returns>
public static string GetAccessToken(string clientId, string secretKey, string code, string callbackUrl, out DateTime expiredDate)
{
var accessTokenUrl = GetLinkedInAccessTokenUrl(clientId, secretKey, code, callbackUrl);
var response = SerializeUtilities.Deserialize <LinkedInAccessToken>(WebUtilities.GetRequest(accessTokenUrl));
expiredDate = DateTime.UtcNow.AddSeconds(response.expires_in);
return(response.access_token);
}
/// <summary>
/// Get url request
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <returns></returns>
public static T GetRequest <T>(string url) where T : class
{
using (var client = new WebClient())
{
var content = client.DownloadString(url);
return(SerializeUtilities.Deserialize <T>(content));
}
}
/// <summary>
/// Post status
/// </summary>
/// <param name="model"></param>
/// <param name="network"></param>
/// <returns></returns>
public ResponseModel Post(SocialMessageModel model, SocialMediaEnums.SocialNetwork network)
{
try
{
var token = GetActiveTokenOfSocialMedia(network);
if (token != null)
{
object response = null;
var authorizeModel = new SocialMediaResponseModel
{
AppId = token.AppId,
AppSecret = token.AppSecret,
AccessToken = token.AccessToken,
AccessTokenSecret = token.AccessTokenSecret
};
switch (network)
{
case SocialMediaEnums.SocialNetwork.Facebook:
response = SocialUtilities.PostFacebookStatus(authorizeModel, model);
break;
case SocialMediaEnums.SocialNetwork.Twitter:
response = SocialUtilities.PostTwitterStatus(authorizeModel, model);
break;
case SocialMediaEnums.SocialNetwork.LinkedIn:
response = SocialUtilities.PostLinkedInStatus(authorizeModel, model);
break;
}
var responseResult = string.Empty;
if (response != null)
{
responseResult = SerializeUtilities.Serialize(response);
}
return(new ResponseModel
{
Success = true,
Data = responseResult
});
}
return(new ResponseModel
{
Success = false,
Message = T("SocialMediaToken_Message_ObjectNotFound")
});
}
catch (Exception exception)
{
return(new ResponseModel(exception));
}
}
protected override void OnReceived(byte[] buffer, long offset, long size)
{
Console.WriteLine(Encoding.UTF8.GetString(buffer, (int)offset, (int)size));
ChatMsg model;
if (SerializeUtilities.ChatMsgDeserializer(out model, Encoding.UTF8.GetString(buffer, (int)offset, (int)size)))
{
Program.chatMsgCollection.Add(model);
}
}
public SubscriptionManageModel(Page page)
: this()
{
var parameterModel = new SubscriptionPageParameterModel(page);
Parameters = SerializeUtilities.Serialize(parameterModel);
Module = SubscriptionEnums.SubscriptionModule.Page;
SubscriptionType = SubscriptionEnums.SubscriptionType.Midnight;
}
/// <summary>
/// Get url request
/// </summary>
/// <param name="url"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string PostRequest(string url, object data)
{
using (var client = new WebClient())
{
client.Headers.Add("Content-Type", "application/json");
var dataString = SerializeUtilities.Serialize(data);
return(client.UploadString(url, dataString));
}
}
public void ConvertByteArrayToInt16IllegalByteLen()
{
byte[] array = new byte[1];
Int16 testval =
SerializeUtilities.ConvertByteArrayToInt16(array, Endianness.big_endian);
Assert.AreEqual(0, testval);
testval =
SerializeUtilities.ConvertByteArrayToInt16(array, Endianness.little_endian);
Assert.AreEqual(0, testval);
}
/// <summary>
/// Get fields
/// </summary>
/// <param name="fields"></param>
/// <returns></returns>
private dynamic GetFields(IEnumerable <FormComponentFieldBase> fields)
{
//TODO: update here using http://stackoverflow.com/questions/26874014/serialize-data-to-json-string-with-dynamic-property-names
const string jsonString = @"
""{0}"" : {1}";
var json = string.Join(",", fields.Select(field => string.Format(jsonString, field.Name, field.Attributes)));
json = string.Format(@"
{{{0}}}", json);
return(SerializeUtilities.Deserialize <dynamic>(json));
}
public FormComponentFieldManageModel(FormComponentField formComponentField)
: this()
{
Id = formComponentField.Id;
Name = formComponentField.Name;
Attributes = SerializeUtilities.Deserialize <FormComponentFieldAttributeModel>(formComponentField.Attributes);
FormComponentId = formComponentField.FormComponentId;
FormComponents = _formComponentService.GetFormComponents(formComponentField.FormComponentId);
RecordOrder = formComponentField.RecordOrder;
}
public WhereClause Generate(bool search, string filters, Type targetSearchType)
{
_formatObjects = new List <object>();
return(new WhereClause
{
Clause = search && !String.IsNullOrEmpty(filters)
? ParseFilter(SerializeUtilities.Deserialize <JqGridFilter>(filters), targetSearchType).ToString()
: String.Empty,
FormatObjects = _formatObjects.ToArray()
});
}
/// <summary>
/// Get default components
/// </summary>
/// <returns></returns>
private string GetDefaultFormComponents()
{
var components = _formDefaultComponentRepository.GetAll().ToList();
var data = components.Select(c => new FormData
{
title = c.Name,
template = c.FormComponentTemplate.Name,
fields = GetFields(c.FormDefaultComponentFields)
});
return(SerializeUtilities.Serialize(data));
}
/// <summary>
/// Get contact search details models
/// </summary>
/// <param name="queries"></param>
/// <returns></returns>
public IEnumerable <ContactSearchDetailsModel> GetContactSearchDetailsModels(string queries)
{
if (!string.IsNullOrEmpty(queries))
{
// Deserialize contact queries string to object
var contactSearchModels = SerializeUtilities.Deserialize <List <ContactSearchModel> >(queries);
return
(contactSearchModels.Select(contactSearchModel => new ContactSearchDetailsModel(contactSearchModel)));
}
return(new List <ContactSearchDetailsModel>());
}
/// <summary>
/// Get all contacts that fit queries
/// </summary>
/// <param name="queries"></param>
/// <returns></returns>
public IQueryable <Contact> GetContacts(string queries)
{
// If queries is empty, return empty list
if (string.IsNullOrEmpty(queries))
{
return(new List <Contact>().AsQueryable());
}
var contactSearchModels = SerializeUtilities.Deserialize <List <ContactSearchModel> >(queries);
return(_contactService.SearchContacts(contactSearchModels));
}
public WidgetTemplateManageModel(WidgetTemplate widgetTemplate)
{
Id = widgetTemplate.Id;
Name = widgetTemplate.Name;
Content = widgetTemplate.Content;
FullContent = widgetTemplate.FullContent;
Shortcuts = SerializeUtilities.Deserialize <List <Shortcut> >(widgetTemplate.Widgets);
Script = widgetTemplate.Script;
Style = widgetTemplate.Style;
DataType = widgetTemplate.DataType;
IsDefaultTemplate = widgetTemplate.IsDefaultTemplate;
Widget = widgetTemplate.Widget;
}
public void ConvertInt16ToBytesTestEndianness()
{
Int16 testVal = 0x6985;
byte[] bigEndian =
SerializeUtilities.ConvertInt16ToByteArray(testVal, Endianness.big_endian);
byte[] littleEndian =
SerializeUtilities.ConvertInt16ToByteArray(testVal, Endianness.little_endian);
Assert.AreEqual((byte)((testVal >> 8) & 0xFF), bigEndian[0]);
Assert.AreEqual((byte)(testVal & 0xFF), bigEndian[1]);
Assert.AreEqual((byte)(testVal & 0xFF), littleEndian[0]);
Assert.AreEqual((byte)((testVal >> 8) & 0xFF), littleEndian[1]);
}
public string GetGridSettings(string name)
{
var setting = _userService.GetUserGridSetting(WorkContext.CurrentUser.Id, name);
if (setting == null)
{
setting = new GridSettingItem
{
Name = name,
Columns = new List <ColumnSetting>()
};
}
return(SerializeUtilities.Serialize(setting).RemoveNewLine());
}
