// AddError structures errors to be logged or returned to client
func (di *DatabaseImport) AddError(value string, errMsg string, columns ...string) {
di.Errors = append(di.Errors, &ImportError{
Line: di.Parser.Line,
SiteCode: di.CurrentSite.Code,
Columns: columns,
Value: value,
ErrMsg: translate.T(di.Parser.UserLang, errMsg),
})
di.CurrentSite.HasError = true
// Store site as containing error
if di.CurrentSite.Code != "" {
if _, ok := di.SitesWithError[di.CurrentSite.Code]; !ok {
di.SitesWithError[di.CurrentSite.Code] = true
}
}
}
func ChronologiesListCsv(w http.ResponseWriter, r *http.Request, proute routes.Proute) {
params := proute.Params.(*ChronologyListCsvParams)
// fmt.Println("params : ", params)
// transaction begin...
tx, err := db.DB.Beginx()
if err != nil {
userSqlError(w, err)
return
}
// get the user
_user, _ := proute.Session.Get("user")
user := _user.(model.User)
answer, err := chronologiesGetTree(tx, params.Id, user)
if err != nil {
_ = tx.Rollback()
userSqlError(w, err)
return
}
// fmt.Println("answer: ", answer)
// commit...
err = tx.Commit()
if err != nil {
log.Println("commit failed")
userSqlError(w, err)
_ = tx.Rollback()
return
}
if params.Dl != "" {
w.Header().Set("Content-Type", "text/csv")
}
csvwriter := csv.NewWriter(w)
csvwriter.Comma = ';'
csvwriter.Write([]string{
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_NAME_L1"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_START_L1"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_END_L1"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_NAME_L2"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_START_L2"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_END_L2"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_NAME_L3"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_START_L3"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_END_L3"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_NAME_L4"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_START_L4"),
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_PERIOD_END_L4"),
})
row := make([]string, 12)
recurseprint(&answer.ChronologyTreeStruct, csvwriter, &row, params.Isocode, 0, 0)
csvwriter.Write(row)
csvwriter.Write([]string{
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_NAME") + ": " + answer.Name[params.Isocode],
})
csvwriter.Write([]string{
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_DESCRIPTION") + ": " + answer.Description[params.Isocode],
})
csvwriter.Write([]string{
translate.T(params.Isocode, "CHRONODITOR.CSVEXPORT.T_CREDITS") + ": " + answer.Credits,
})
csvwriter.Flush()
//w.Write([]byte(outp))
}
// ExportCSV exports database and sites as as csv file
func (d *Database) ExportCSV(tx *sqlx.Tx, siteIDs ...[]int) (outp string, err error) {
var buff bytes.Buffer
w := csv.NewWriter(&buff)
w.Comma = ';'
w.UseCRLF = true
err = w.Write([]string{"SITE_SOURCE_ID", "SITE_NAME", "MAIN_CITY_NAME", "GEONAME_ID", "PROJECTION_SYSTEM", "LONGITUDE", "LATITUDE", "ALTITUDE", "CITY_CENTROID", "STATE_OF_KNOWLEDGE", "OCCUPATION", "STARTING_PERIOD", "ENDING_PERIOD", "CARAC_NAME", "CARAC_LVL1", "CARAC_LVL2", "CARAC_LVL3", "CARAC_LVL4", "CARAC_EXP", "BIBLIOGRAPHY", "COMMENTS"})
if err != nil {
log.Println("database::ExportCSV : ", err.Error())
}
w.Flush()
// Datatabase isocode
err = tx.Get(d, "SELECT name, default_language FROM \"database\" WHERE id = $1", d.Id)
if err != nil {
return
}
// Cache characs
characs := make(map[int]string)
q := "WITH RECURSIVE nodes_cte(id, path) AS (SELECT ca.id, cat.name::TEXT AS path FROM charac AS ca LEFT JOIN charac_tr cat ON ca.id = cat.charac_id LEFT JOIN lang ON cat.lang_isocode = lang.isocode WHERE lang.isocode = $1 AND ca.parent_id = 0 UNION ALL SELECT ca.id, (p.path || ';' || cat.name) FROM nodes_cte AS p, charac AS ca LEFT JOIN charac_tr cat ON ca.id = cat.charac_id LEFT JOIN lang ON cat.lang_isocode = lang.isocode WHERE lang.isocode = $1 AND ca.parent_id = p.id) SELECT * FROM nodes_cte AS n ORDER BY n.id ASC\n"
rows, err := tx.Query(q, d.Default_language)
switch {
case err == sql.ErrNoRows:
rows.Close()
return outp, nil
case err != nil:
rows.Close()
return
}
for rows.Next() {
var id int
var path string
if err = rows.Scan(&id, &path); err != nil {
return
}
characs[id] = path
}
q = "SELECT s.code, s.name, s.city_name, s.city_geonameid, ST_X(s.geom::geometry) as longitude, ST_Y(s.geom::geometry) as latitude, ST_X(s.geom_3d::geometry) as longitude_3d, ST_Y(s.geom_3d::geometry) as latitude3d, ST_Z(s.geom_3d::geometry) as altitude, s.centroid, s.occupation, sr.start_date1, sr.start_date2, sr.end_date1, sr.end_date2, src.exceptional, src.knowledge_type, srctr.bibliography, srctr.comment, c.id as charac_id FROM site s LEFT JOIN site_range sr ON s.id = sr.site_id LEFT JOIN site_tr str ON s.id = str.site_id LEFT JOIN site_range__charac src ON sr.id = src.site_range_id LEFT JOIN site_range__charac_tr srctr ON src.id = srctr.site_range__charac_id LEFT JOIN charac c ON src.charac_id = c.id WHERE s.database_id = $1 AND str.lang_isocode IS NULL OR str.lang_isocode = $2 ORDER BY s.id, sr.id"
rows2, err := tx.Query(q, d.Id, d.Default_language)
if err != nil {
rows2.Close()
return
}
for rows2.Next() {
var (
code string
name string
city_name string
city_geonameid int
longitude float64
latitude float64
longitude3d float64
latitude3d float64
altitude3d float64
centroid bool
occupation string
start_date1 int
start_date2 int
end_date1 int
end_date2 int
knowledge_type string
exceptional bool
bibliography string
comment string
charac_id int
slongitude string
slatitude string
saltitude string
scentroid string
soccupation string
scharacs string
scharac_name string
scharac_lvl1 string
scharac_lvl2 string
scharac_lvl3 string
scharac_lvl4 string
sexceptional string
// description string
)
if err = rows2.Scan(&code, &name, &city_name, &city_geonameid, &longitude, &latitude, &longitude3d, &latitude3d, &altitude3d, ¢roid, &occupation, &start_date1, &start_date2, &end_date1, &end_date2, &exceptional, &knowledge_type, &bibliography, &comment, &charac_id); err != nil {
log.Println(err)
rows2.Close()
return
}
// Geonameid
var cgeonameid string
if city_geonameid != 0 {
cgeonameid = strconv.Itoa(city_geonameid)
}
// Longitude
slongitude = strconv.FormatFloat(longitude, 'f', -1, 32)
// Latitude
slatitude = strconv.FormatFloat(latitude, 'f', -1, 32)
// Altitude
if longitude3d == 0 && latitude3d == 0 && altitude3d == 0 {
saltitude = ""
} else {
saltitude = strconv.FormatFloat(altitude3d, 'f', -1, 32)
}
// Centroid
if centroid {
scentroid = translate.T(d.Default_language, "IMPORT.CSVFIELD_ALL.T_LABEL_YES")
} else {
scentroid = translate.T(d.Default_language, "IMPORT.CSVFIELD_ALL.T_LABEL_NO")
}
// Occupation
switch occupation {
case "not_documented":
soccupation = translate.T(d.Default_language, "IMPORT.CSVFIELD_OCCUPATION.T_LABEL_NOT_DOCUMENTED")
case "single":
soccupation = translate.T(d.Default_language, "IMPORT.CSVFIELD_OCCUPATION.T_LABEL_SINGLE")
case "continuous":
soccupation = translate.T(d.Default_language, "IMPORT.CSVFIELD_OCCUPATION.T_LABEL_CONTINUOUS")
case "multiple":
soccupation = translate.T(d.Default_language, "IMPORT.CSVFIELD_OCCUPATION.T_LABEL_MULTIPLE")
}
// State of knowledge
switch knowledge_type {
case "not_documented":
knowledge_type = translate.T(d.Default_language, "IMPORT.CSVFIELD_STATE_OF_KNOWLEDGE.T_LABEL_NOT_DOCUMENTED")
case "literature":
knowledge_type = translate.T(d.Default_language, "IMPORT.CSVFIELD_STATE_OF_KNOWLEDGE.T_LABEL_LITERATURE")
case "prospected_aerial":
knowledge_type = translate.T(d.Default_language, "IMPORT.CSVFIELD_STATE_OF_KNOWLEDGE.T_LABEL_PROSPECTED_AERIAL")
case "prospected_pedestrian":
knowledge_type = translate.T(d.Default_language, "IMPORT.CSVFIELD_STATE_OF_KNOWLEDGE.T_LABEL_PROSPECTED_PEDESTRIAN")
case "surveyed":
knowledge_type = translate.T(d.Default_language, "IMPORT.CSVFIELD_STATE_OF_KNOWLEDGE.T_LABEL_SURVEYED")
case "dig":
knowledge_type = translate.T(d.Default_language, "IMPORT.CSVFIELD_STATE_OF_KNOWLEDGE.T_LABEL_DIG")
}
// Revert hack on dates
if start_date1 < 0 && start_date1 > math.MinInt32 {
start_date1--
}
if start_date2 < 0 && start_date2 > math.MinInt32 {
start_date2--
}
if end_date1 < 0 && end_date1 > math.MinInt32 {
end_date1--
}
if end_date2 < 0 && end_date2 > math.MinInt32 {
end_date2--
}
// Starting period
startingPeriod := ""
if start_date1 != math.MinInt32 {
startingPeriod += strconv.Itoa(start_date1)
}
if start_date1 != math.MinInt32 && start_date2 != math.MaxInt32 && start_date1 != start_date2 {
startingPeriod += ":"
}
if start_date2 != math.MaxInt32 && start_date1 != start_date2 {
startingPeriod += strconv.Itoa(start_date2)
}
if startingPeriod == "" {
startingPeriod = translate.T(d.Default_language, "IMPORT.CSVFIELD_ALL.T_CHECK_UNDETERMINED")
}
// Ending period
endingPeriod := ""
if end_date1 != math.MinInt32 {
endingPeriod += strconv.Itoa(end_date1)
}
if end_date1 != math.MinInt32 && end_date2 != math.MaxInt32 && end_date1 != end_date2 {
endingPeriod += ":"
}
if end_date2 != math.MaxInt32 && end_date1 != end_date2 {
endingPeriod += strconv.Itoa(end_date2)
}
if endingPeriod == "" {
endingPeriod = translate.T(d.Default_language, "IMPORT.CSVFIELD_ALL.T_CHECK_UNDETERMINED")
}
// Caracs
var characPath = characs[charac_id]
// fmt.Println(code, characPath)
num := strings.Count(characPath, ";")
if num < 4 {
scharacs += characPath + strings.Repeat(";", 4-num)
} else {
scharacs = characPath
}
scharac_lvl2 = ""
scharac_lvl3 = ""
scharac_lvl4 = ""
for i, c := range strings.Split(scharacs, ";") {
// fmt.Println(i, c)
switch i {
case 0:
scharac_name = c
case 1:
scharac_lvl1 = c
case 2:
scharac_lvl2 = c
case 3:
scharac_lvl3 = c
case 4:
scharac_lvl4 = c
}
}
// fmt.Println(scharac_name, scharac_lvl1, scharac_lvl2, scharac_lvl3, scharac_lvl4)
// fmt.Println(startingPeriod, endingPeriod)
// Caracs exp
if exceptional {
sexceptional = translate.T(d.Default_language, "IMPORT.CSVFIELD_ALL.T_LABEL_YES")
} else {
sexceptional = translate.T(d.Default_language, "IMPORT.CSVFIELD_ALL.T_LABEL_NO")
}
line := []string{code, name, city_name, cgeonameid, "4326", slongitude, slatitude, saltitude, scentroid, knowledge_type, soccupation, startingPeriod, endingPeriod, scharac_name, scharac_lvl1, scharac_lvl2, scharac_lvl3, scharac_lvl4, sexceptional, bibliography, comment}
err := w.Write(line)
w.Flush()
if err != nil {
log.Println("database::ExportCSV : ", err.Error())
}
}
return buff.String(), nil
}
// Send sends a mail. Amazing no ?
func Send(to []string, subject, body string, langIsoCode ...string) (err error) {
lang := "en"
subject = strings.TrimSpace(subject)
body = strings.TrimSpace(body)
if langIsoCode[0] != "" {
lang = langIsoCode[0]
}
if subject == "" {
return errors.New("Subject can't be empty")
}
if body == "" {
return errors.New("Message can't be empty")
}
if isTranslatableStringRegexp.MatchString(subject) {
subject = translate.T(lang, subject)
}
if isTranslatableStringRegexp.MatchString(body) {
body = translate.T(lang, body)
}
/*
message := "From: " + config.Main.Mail.From + "\n" +
"To: " + "*****@*****.**" + "\n" +
"Subject: " + subject + "\n\n" +
body
auth := smtp.PlainAuth("", config.Main.Mail.User, config.Main.Mail.Password, config.Main.Mail.Host)
err = smtp.SendMail(config.Main.Mail.Host, auth, config.Main.Mail.From, to, []byte(message))
fmt.Println(err)
*/ // the basics
// setup the remote smtpserver & auth info
auth := smtp.PlainAuth("", config.Main.Mail.User, config.Main.Mail.Password, config.Main.Mail.Host)
// setup a map for the headers
header := make(map[string]string)
header["From"] = config.Main.Mail.From
header["To"] = strings.Join(to, ",")
header["Subject"] = subject
// setup the message
message := ""
for k, v := range header {
message += fmt.Sprintf("%s: %s\r\n", k, v)
}
message += "\r\n" + body
// create the smtp connection
c, err := smtp.Dial(config.Main.Mail.Host)
if err != nil {
return errors.Annotate(err, "Dial failed")
}
// set some TLS options, so we can make sure a non-verified cert won't stop us sending
host, _, _ := net.SplitHostPort(config.Main.Mail.Host)
tlc := &tls.Config{
InsecureSkipVerify: true,
ServerName: host,
}
if err = c.StartTLS(tlc); err != nil {
return errors.Annotate(err, "Start tls handshake failed")
}
// auth stuff
if err = c.Auth(auth); err != nil {
return errors.Annotate(err, "Auth failed")
}
// To && From
if err = c.Mail(config.Main.Mail.From); err != nil {
return errors.Annotate(err, "Setting 'From' header failed")
}
if err = c.Rcpt(strings.Join(to, ",")); err != nil {
return errors.Annotate(err, "Setting 'To' header failed")
}
// Data
w, err := c.Data()
if err != nil {
return errors.Annotate(err, "Setting data failed")
}
_, err = w.Write([]byte(message))
if err != nil {
return errors.Annotate(err, "Writing message failed")
}
err = w.Close()
if err != nil {
return errors.Annotate(err, "Closing connexion failed")
}
c.Quit()
return
}
func (p *Parser) AddError(errMsg string, columns ...string) {
p.Errors = append(p.Errors, &ParserError{
Columns: columns,
ErrMsg: translate.T(p.UserLang, errMsg),
})
}
// lowerTranslation return translation in lower case
func (di *DatabaseImport) lowerTranslation(s string) string {
return cleanAndLower(translate.T(di.Parser.Lang, s))
}
func Start() {
fmt.Println(translate.T("fr", "MAIN.CONSOLE_MSG.T_SERVER_STARTING", "4.0.0"))
webserver.StartServer()
}